Rev 207 | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed
Rev 207 | Rev 265 | ||
---|---|---|---|
1 | /********************************************************************\ |
1 | /********************************************************************\ |
2 | 2 | ||
3 | Name: drsread.cpp |
3 | Name: drsread.cpp |
4 | Created by: Rok Pestotnik |
4 | Created by: Rok Pestotnik |
5 | 5 | ||
6 | Contents: Simple example application to read out a DRS4 |
6 | Contents: Simple example application to read out a DRS4 |
7 | evaluation board and save into the data file |
7 | evaluation board and save into the data file |
8 | Interface dll for LabWindows CVI |
8 | Interface dll for LabWindows CVI |
9 | 9 | ||
10 | \********************************************************************/ |
10 | \********************************************************************/ |
11 | #ifdef DLLMAIN |
11 | #ifdef DLLMAIN |
12 | #define DLLEXPORT __declspec(dllexport) |
12 | #define DLLEXPORT __declspec(dllexport) |
13 | #else |
13 | #else |
14 | #define DLLEXPORT |
14 | #define DLLEXPORT |
15 | #endif |
15 | #endif |
16 | 16 | ||
17 | 17 | ||
18 | #include <stdio.h> |
18 | #include <stdio.h> |
19 | #include <string.h> |
19 | #include <string.h> |
20 | #include <stdlib.h> |
20 | #include <stdlib.h> |
21 | 21 | ||
22 | #include <math.h> |
22 | #include <math.h> |
23 | #include <time.h> |
23 | #include <time.h> |
24 | #include <signal.h> |
24 | #include <signal.h> |
25 | 25 | ||
26 | #include <TFile.h> |
26 | #include <TFile.h> |
27 | #include <TH2F.h> |
27 | #include <TH2F.h> |
28 | #include <TCanvas.h> |
28 | #include <TCanvas.h> |
29 | //#include <TApplication.h> |
29 | //#include <TApplication.h> |
30 | 30 | ||
31 | #ifdef _MSC_VER |
31 | #ifdef _MSC_VER |
32 | 32 | ||
33 | #include "gettimeofday.h" |
33 | #include "gettimeofday.h" |
34 | #include "timer.h" |
34 | #include "timer.h" |
35 | 35 | ||
36 | #define DIR_SEPARATOR '\\' |
36 | #define DIR_SEPARATOR '\\' |
37 | 37 | ||
38 | #elif defined(OS_LINUX) || defined(OS_DARWIN) |
38 | #elif defined(OS_LINUX) || defined(OS_DARWIN) |
39 | 39 | ||
40 | #define O_BINARY 0 |
40 | #define O_BINARY 0 |
41 | #include <unistd.h> |
41 | #include <unistd.h> |
42 | #include <ctype.h> |
42 | #include <ctype.h> |
43 | #include <sys/ioctl.h> |
43 | #include <sys/ioctl.h> |
44 | #include <errno.h> |
44 | #include <errno.h> |
45 | #define DIR_SEPARATOR '/' |
45 | #define DIR_SEPARATOR '/' |
46 | #endif |
46 | #endif |
47 | 47 | ||
48 | #include "DRS.h" |
48 | #include "DRS.h" |
49 | #include "drsread.h" |
49 | #include "drsread.h" |
50 | 50 | ||
51 | 51 | ||
52 | /*------------------------------------------------------------------*/ |
52 | /*------------------------------------------------------------------*/ |
53 | class drssettings { |
53 | class drssettings { |
54 | static drssettings *s_instance; |
54 | static drssettings *s_instance; |
55 | public: |
55 | public: |
56 | drssettings(){ |
56 | drssettings(){ |
57 | mask = 0xF; |
57 | mask = 0xF; |
58 | range = 0; |
58 | range = 0; |
59 | trigger_type = 1; |
59 | trigger_type = 1; |
60 | sampling_frequency = 5; |
60 | sampling_frequency = 5; |
61 | trigger_delay = 0; |
61 | trigger_delay = 0; |
62 | trigger_channel=0; |
62 | trigger_channel=0; |
63 | trigger_polarity=false; |
63 | trigger_polarity=false; |
64 | trigger_level=0.05; |
64 | trigger_level=0.05; |
65 | 65 | ||
66 | }; |
66 | }; |
67 | ~drssettings(){}; |
67 | ~drssettings(){}; |
68 | static drssettings *instance() |
68 | static drssettings *instance() |
69 | { |
69 | { |
70 | if (!s_instance) |
70 | if (!s_instance) |
71 | s_instance = new drssettings; |
71 | s_instance = new drssettings; |
72 | return s_instance; |
72 | return s_instance; |
73 | }; |
73 | }; |
74 | 74 | ||
75 | 75 | ||
76 | unsigned char mask; |
76 | unsigned char mask; |
77 | double range; |
77 | double range; |
78 | int trigger_type; // 0 software, 1 fast hardware, 2 slow hardware |
78 | int trigger_type; // 0 software, 1 fast hardware, 2 slow hardware |
79 | int trigger_channel; |
79 | int trigger_channel; |
80 | int sampling_frequency; |
80 | int sampling_frequency; |
81 | double trigger_delay; |
81 | double trigger_delay; |
82 | double trigger_level; |
82 | double trigger_level; |
83 | bool trigger_polarity; |
83 | bool trigger_polarity; |
84 | }; |
84 | }; |
85 | drssettings *drssettings::s_instance = 0; |
85 | drssettings *drssettings::s_instance = 0; |
86 | drssettings *DRSParameters; |
86 | drssettings *DRSParameters; |
87 | DLLEXPORT void DRSSetMask(int mask){ drssettings::instance()->mask;}; |
87 | DLLEXPORT void DRSSetMask(int mask){ drssettings::instance()->mask;}; |
88 | DLLEXPORT void DRSSetTriggerType(int type){ drssettings::instance()->trigger_type = type;}; |
88 | DLLEXPORT void DRSSetTriggerType(int type){ drssettings::instance()->trigger_type = type;}; |
89 | DLLEXPORT void DRSSetFrequency(int freq){ drssettings::instance()->sampling_frequency = freq;}; |
89 | DLLEXPORT void DRSSetFrequency(int freq){ drssettings::instance()->sampling_frequency = freq;}; |
90 | DLLEXPORT void DRSSetRange(double range){ drssettings::instance()->range = range;}; |
90 | DLLEXPORT void DRSSetRange(double range){ drssettings::instance()->range = range;}; |
91 | DLLEXPORT void DRSSetTriggerChannel(int channel){ drssettings::instance()->trigger_channel = channel;}; |
91 | DLLEXPORT void DRSSetTriggerChannel(int channel){ drssettings::instance()->trigger_channel = channel;}; |
92 | DLLEXPORT void DRSSetTriggerDelay(double delay){ drssettings::instance()->trigger_delay = delay;}; |
92 | DLLEXPORT void DRSSetTriggerDelay(double delay){ drssettings::instance()->trigger_delay = delay;}; |
93 | DLLEXPORT void DRSSetTriggerLevel(double level){ drssettings::instance()->trigger_level = level;}; |
93 | DLLEXPORT void DRSSetTriggerLevel(double level){ drssettings::instance()->trigger_level = level;}; |
94 | DLLEXPORT void DRSSetTriggerPolarity(int polarity){ drssettings::instance()->trigger_polarity = (polarity==1);}; |
94 | DLLEXPORT void DRSSetTriggerPolarity(int polarity){ drssettings::instance()->trigger_polarity = (polarity==1);}; |
95 | 95 | ||
96 | 96 | ||
97 | static int DRSTimeout; |
97 | static int DRSTimeout; |
98 | 98 | ||
99 | DLLEXPORT int DRSIsTimeout() |
99 | DLLEXPORT int DRSIsTimeout() |
100 | { |
100 | { |
101 | return DRSTimeout; |
101 | return DRSTimeout; |
102 | } |
102 | } |
103 | 103 | ||
104 | DLLEXPORT void DRSSetTimeout ( void ) |
104 | DLLEXPORT void DRSSetTimeout ( void ) |
105 | { |
105 | { |
106 | DRSTimeout=1; |
106 | DRSTimeout=1; |
107 | printf("->>> Timer Out !!!\n"); |
107 | printf("->>> Timer Out !!!\n"); |
108 | } |
108 | } |
109 | 109 | ||
110 | static DRS *drs=NULL; |
110 | static DRS *drs=NULL; |
- | 111 | ||
- | 112 | ||
- | 113 | DLLEXPORT int DRSCalibrateTiming( ) |
|
- | 114 | { |
|
- | 115 | DRSBoard *b; |
|
- | 116 | if (drs == NULL) drs = new DRS(); |
|
- | 117 | if (!drs) return -1; |
|
- | 118 | DRSParameters = drssettings::instance(); |
|
- | 119 | ||
- | 120 | //fCalMode = 2; |
|
- | 121 | if (drs->GetNumberOfBoards() ) { |
|
- | 122 | /* continue working with first board only */ |
|
- | 123 | b = drs->GetBoard(0); |
|
- | 124 | ||
- | 125 | if (b->GetFirmwareVersion() < 13279) |
|
- | 126 | printf("Firmware revision 13279 or later\nrequired for timing calibration\n"); |
|
- | 127 | else if (b->GetInputRange() != 0) |
|
- | 128 | printf("Timing calibration can only be done\nat the -0.5V to +0.5V input range\n"); |
|
- | 129 | ||
- | 130 | else { |
|
- | 131 | ||
- | 132 | ||
- | 133 | /* remember current settings */ |
|
- | 134 | double acalVolt = b->GetAcalVolt(); |
|
- | 135 | int acalMode = b->GetAcalMode(); |
|
- | 136 | int tcalFreq = b->GetTcalFreq(); |
|
- | 137 | int tcalLevel = b->GetTcalLevel(); |
|
- | 138 | int tcalSource = b->GetTcalSource(); |
|
- | 139 | int flag1 = b->GetTriggerEnable(0); |
|
- | 140 | int flag2 = b->GetTriggerEnable(1); |
|
- | 141 | int trgSource = b->GetTriggerSource(); |
|
- | 142 | int trgDelay = b->GetTriggerDelay(); |
|
- | 143 | double range = b->GetInputRange(); |
|
- | 144 | int config = b->GetReadoutChannelConfig(); |
|
- | 145 | ||
- | 146 | ||
- | 147 | int status = b->CalibrateTiming(NULL); |
|
- | 148 | ||
- | 149 | if (!status) |
|
- | 150 | printf("Error performing timing calibration, please check waveforms and redo voltage calibration.\n"); |
|
- | 151 | else |
|
- | 152 | printf("Timing calibration successfully finished.\n"); |
|
- | 153 | ||
- | 154 | ||
- | 155 | /* restore old values */ |
|
- | 156 | b->EnableAcal(acalMode, acalVolt); |
|
- | 157 | b->EnableTcal(tcalFreq, tcalLevel); |
|
- | 158 | b->SelectClockSource(tcalSource); |
|
- | 159 | b->EnableTrigger(flag1, flag2); |
|
- | 160 | b->SetTriggerSource(trgSource); |
|
- | 161 | b->SetTriggerDelayPercent(trgDelay); |
|
- | 162 | b->SetInputRange(range); |
|
- | 163 | b->SetChannelConfig(config, 8, 8); |
|
- | 164 | ||
- | 165 | if (b->GetBoardType() == 5) |
|
- | 166 | b->SetTranspMode(1); // Evaluation board with build-in trigger |
|
- | 167 | else |
|
- | 168 | b->SetTranspMode(1); // VPC Mezzanine board |
|
- | 169 | ||
- | 170 | return status; |
|
- | 171 | } |
|
- | 172 | ||
- | 173 | } |
|
- | 174 | return -1; |
|
- | 175 | } |
|
- | 176 | ||
111 | 177 | ||
112 | DLLEXPORT int DRSInit() |
178 | DLLEXPORT int DRSInit() |
113 | { |
179 | { |
114 | 180 | ||
115 | DRSBoard *b; |
181 | DRSBoard *b; |
116 | /* do drsinitial scan */ |
182 | /* do drsinitial scan */ |
117 | drs = new DRS(); |
183 | if (drs == NULL) drs = new DRS(); |
118 | if (!drs) return -1; |
184 | if (!drs) return -1; |
119 | DRSParameters = drssettings::instance(); |
185 | DRSParameters = drssettings::instance(); |
120 | 186 | ||
121 | /* show any found board(s) */ |
187 | /* show any found board(s) */ |
122 | for (int i=0 ; i<drs->GetNumberOfBoards() ; i++) { |
188 | for (int i=0 ; i<drs->GetNumberOfBoards() ; i++) { |
123 | b = drs->GetBoard(i); |
189 | b = drs->GetBoard(i); |
124 | printf("Found DRS4 evaluation board, serial #%d, firmware revision %d\n", |
190 | printf("Found DRS4 evaluation board, serial #%d, firmware revision %d\n", |
125 | b->GetBoardSerialNumber(), b->GetFirmwareVersion()); |
191 | b->GetBoardSerialNumber(), b->GetFirmwareVersion()); |
126 | } |
192 | } |
127 | 193 | ||
128 | /* exit if no board found */ |
194 | /* exit if no board found */ |
129 | int nBoards = drs->GetNumberOfBoards(); |
195 | int nBoards = drs->GetNumberOfBoards(); |
130 | if (nBoards == 0) { |
196 | if (nBoards == 0) { |
131 | printf("No DRS4 evaluation board found\n"); |
197 | printf("No DRS4 evaluation board found\n"); |
132 | return -2; |
198 | return -2; |
133 | } |
199 | } |
134 | 200 | ||
135 | /* continue working with first board only */ |
201 | /* continue working with first board only */ |
136 | b = drs->GetBoard(0); |
202 | b = drs->GetBoard(0); |
137 | 203 | ||
138 | /* drsinitialize board */ |
204 | /* drsinitialize board */ |
139 | b->Init(); |
205 | b->Init(); |
140 | 206 | ||
141 | /* set sampling frequency default 5 */ |
207 | /* set sampling frequency default 5 */ |
142 | b->SetFrequency(DRSParameters->sampling_frequency, true); |
208 | b->SetFrequency(DRSParameters->sampling_frequency, true); |
143 | 209 | ||
144 | /* enable transparent mode needed for analog trigger */ |
210 | /* enable transparent mode needed for analog trigger */ |
145 | b->SetTranspMode(1); |
211 | b->SetTranspMode(1); |
146 | 212 | ||
147 | /* set input range to -0.5V ... +0.5V -> range=0 */ |
213 | /* set input range to -0.5V ... +0.5V -> range=0 */ |
148 | b->SetInputRange(DRSParameters->range); |
214 | b->SetInputRange(DRSParameters->range); |
149 | 215 | ||
150 | /* use following line to set range to 0..1V */ |
216 | /* use following line to set range to 0..1V */ |
151 | //b->SetInputRange(0.5); |
217 | //b->SetInputRange(0.5); |
152 | 218 | ||
153 | /* use following line to turn on the internal 100 MHz clock connected to all channels */ |
219 | /* use following line to turn on the internal 100 MHz clock connected to all channels */ |
154 | //b->EnableTcal(1); |
220 | //b->EnableTcal(1); |
155 | 221 | ||
156 | /* kaj je to .... |
222 | /* kaj je to .... |
157 | // Set domino mode |
223 | // Set domino mode |
158 | // mode == 0: single sweep |
224 | // mode == 0: single sweep |
159 | // mode == 1: run continously -- default |
225 | // mode == 1: run continously -- default |
160 | b->SetDominoMode(1); |
226 | b->SetDominoMode(1); |
161 | // Set domino activity |
227 | // Set domino activity |
162 | // mode == 0: stop during readout |
228 | // mode == 0: stop during readout |
163 | // mode == 1: keep domino wave running -- default |
229 | // mode == 1: keep domino wave running -- default |
164 | // |
230 | // |
165 | b->SetDominoActive(1); |
231 | b->SetDominoActive(1); |
166 | |
232 | |
167 | // Set readout mode |
233 | // Set readout mode |
168 | // mode == 0: start from first bin -- default |
234 | // mode == 0: start from first bin -- default |
169 | // mode == 1: start from domino stop |
235 | // mode == 1: start from domino stop |
170 | // |
236 | // |
171 | b->SetReadoutMode(1); |
237 | b->SetReadoutMode(1); |
172 | */ |
238 | */ |
173 | 239 | ||
174 | /* use following lines to enable hardware trigger on CH1 at 50 mV positive edge */ |
240 | /* use following lines to enable hardware trigger on CH1 at 50 mV positive edge */ |
175 | printf("Board Type:%d\n",b->GetBoardType() ); |
241 | printf("Board Type:%d\n",b->GetBoardType() ); |
176 | if (b->GetBoardType() >= 8) { // Evaluaiton Board V4&5 |
242 | if (b->GetBoardType() >= 8) { // Evaluaiton Board V4&5 |
177 | 243 | ||
178 | b->EnableTrigger(DRSParameters->trigger_type, 0); // enable hardware trigger - 1 fast trigger, 2 slow trigger, 0 disable hw trigger |
244 | b->EnableTrigger(DRSParameters->trigger_type, 0); // enable hardware trigger - 1 fast trigger, 2 slow trigger, 0 disable hw trigger |
179 | b->SetTriggerSource(1<<DRSParameters->trigger_channel); // set CH1 as source // simple or of single channel |
245 | b->SetTriggerSource(1<<DRSParameters->trigger_channel); // set CH1 as source // simple or of single channel |
180 | } else if (b->GetBoardType() == 7) { // Evaluation Board V3 |
246 | } else if (b->GetBoardType() == 7) { // Evaluation Board V3 |
181 | b->EnableTrigger(0, 1); // lemo off, analog trigger on |
247 | b->EnableTrigger(0, 1); // lemo off, analog trigger on |
182 | b->SetTriggerSource(0); // use CH1 as source |
248 | b->SetTriggerSource(0); // use CH1 as source |
183 | } |
249 | } |
184 | b->SetTriggerLevel(DRSParameters->trigger_level); // 0.05 V |
250 | b->SetTriggerLevel(DRSParameters->trigger_level); // 0.05 V |
185 | b->SetTriggerPolarity(DRSParameters->trigger_polarity); // positive edge |
251 | b->SetTriggerPolarity(DRSParameters->trigger_polarity); // positive edge |
186 | 252 | ||
187 | /* use following lines to set individual trigger elvels */ |
253 | /* use following lines to set individual trigger elvels */ |
188 | //b->SetIndividualTriggerLevel(1, 0.1); |
254 | //b->SetIndividualTriggerLevel(1, 0.1); |
189 | //b->SetIndividualTriggerLevel(2, 0.2); |
255 | //b->SetIndividualTriggerLevel(2, 0.2); |
190 | //b->SetIndividualTriggerLevel(3, 0.3); |
256 | //b->SetIndividualTriggerLevel(3, 0.3); |
191 | //b->SetIndividualTriggerLevel(4, 0.4); |
257 | //b->SetIndividualTriggerLevel(4, 0.4); |
192 | //b->SetTriggerSource(15); |
258 | //b->SetTriggerSource(15); |
193 | 259 | ||
194 | b->SetTriggerDelayNs( DRSParameters->trigger_delay); // zero ns trigger delay |
260 | b->SetTriggerDelayNs( DRSParameters->trigger_delay); // zero ns trigger delay |
195 | 261 | ||
196 | /* use following lines to enable the external trigger */ |
262 | /* use following lines to enable the external trigger */ |
197 | //if (b->GetBoardType() == 8) { // Evaluaiton Board V4 |
263 | //if (b->GetBoardType() == 8) { // Evaluaiton Board V4 |
198 | // b->EnableTrigger(1, 0); // enable hardware trigger |
264 | // b->EnableTrigger(1, 0); // enable hardware trigger |
199 | // b->SetTriggerSource(1<<4); // set external trigger as source |
265 | // b->SetTriggerSource(1<<4); // set external trigger as source |
200 | //} else { // Evaluation Board V3 |
266 | //} else { // Evaluation Board V3 |
201 | // b->EnableTrigger(1, 0); // lemo on, analog trigger off |
267 | // b->EnableTrigger(1, 0); // lemo on, analog trigger off |
202 | // } |
268 | // } |
203 | 269 | ||
204 | return 0; |
270 | return 0; |
205 | 271 | ||
206 | 272 | ||
207 | } |
273 | } |
208 | 274 | ||
209 | static float DRSTimeArray[8][1024]; |
275 | static float DRSTimeArray[8][1024]; |
210 | static float DRSWaveArray[8][1024]; |
276 | static float DRSWaveArray[8][1024]; |
211 | 277 | ||
212 | DLLEXPORT float * DRSGetTime(int ch){ return DRSTimeArray[ch];} |
278 | DLLEXPORT float * DRSGetTime(int ch){ return DRSTimeArray[ch];} |
213 | DLLEXPORT float * DRSGetWave(int ch){ return DRSWaveArray[ch];} |
279 | DLLEXPORT float * DRSGetWave(int ch){ return DRSWaveArray[ch];} |
214 | 280 | ||
215 | DLLEXPORT int DRSRead( int DRStimer) |
281 | DLLEXPORT int DRSRead( int DRStimer) |
216 | { |
282 | { |
217 | 283 | ||
218 | DRSBoard *b = drs->GetBoard(0); |
284 | DRSBoard *b = drs->GetBoard(0); |
219 | 285 | ||
220 | 286 | ||
221 | 287 | ||
222 | /* wait for trigger */ |
288 | /* wait for trigger */ |
223 | 289 | ||
224 | 290 | ||
225 | int tout=1000; /* timeout in mili seconds */ |
291 | int tout=1000; /* timeout in mili seconds */ |
226 | DRSTimeout=0; |
292 | DRSTimeout=0; |
227 | 293 | ||
228 | if (DRStimer) start_timer(tout, &DRSSetTimeout); |
294 | if (DRStimer) start_timer(tout, &DRSSetTimeout); |
229 | 295 | ||
230 | /* start board (activate domino wave) */ |
296 | /* start board (activate domino wave) */ |
231 | b->StartDomino(); |
297 | b->StartDomino(); |
232 | 298 | ||
233 | if (!DRSParameters->trigger_type) b->SoftTrigger(); |
299 | if (!DRSParameters->trigger_type) b->SoftTrigger(); |
234 | 300 | ||
235 | while (b->IsBusy()){ |
301 | while (b->IsBusy()){ |
236 | 302 | ||
237 | if (DRSTimeout) { |
303 | if (DRSTimeout) { |
238 | printf("Waiting for Trigger.. at line %d\n", __LINE__); |
304 | printf("Waiting for Trigger.. at line %d\n", __LINE__); |
239 | 305 | ||
240 | if (DRStimer) stop_timer(); |
306 | if (DRStimer) stop_timer(); |
241 | 307 | ||
242 | return -1; |
308 | return -1; |
243 | } |
309 | } |
244 | }; |
310 | }; |
245 | 311 | ||
246 | 312 | ||
247 | if (DRStimer) stop_timer(); |
313 | if (DRStimer) stop_timer(); |
248 | 314 | ||
249 | 315 | ||
250 | 316 | ||
251 | /* read all waveforms */ |
317 | /* read all waveforms */ |
252 | b->TransferWaves(0, 8); |
318 | b->TransferWaves(0, 8); |
253 | 319 | ||
254 | 320 | ||
255 | for (int k=0;k<4;k++){ |
321 | for (int k=0;k<4;k++){ |
256 | if (! (DRSParameters->mask & ( 0x1<<k )) ) continue; |
322 | if (! (DRSParameters->mask & ( 0x1<<k )) ) continue; |
257 | /* Note: On the evaluation board input #1 is connected to channel 0 and 1 of |
323 | /* Note: On the evaluation board input #1 is connected to channel 0 and 1 of |
258 | the DRS chip, input #2 is connected to channel 2 and 3 and so on. So to |
324 | the DRS chip, input #2 is connected to channel 2 and 3 and so on. So to |
259 | get the input #2 we have to read DRS channel #2, not #1. */ |
325 | get the input #2 we have to read DRS channel #2, not #1. */ |
260 | 326 | ||
261 | /* read time (X) array of k-th channel in ns and waveform (Y) array of k-th channel in mV */ |
327 | /* read time (X) array of k-th channel in ns and waveform (Y) array of k-th channel in mV */ |
262 | b->GetTime(0, 2*k, b->GetTriggerCell(DRSParameters->trigger_channel), DRSTimeArray[k]); |
328 | b->GetTime(0, 2*k, b->GetTriggerCell(DRSParameters->trigger_channel), DRSTimeArray[k]); |
263 | b->GetWave(0, 2*k, DRSWaveArray[k]); |
329 | b->GetWave(0, 2*k, DRSWaveArray[k]); |
264 | 330 | ||
265 | 331 | ||
266 | } |
332 | } |
267 | 333 | ||
268 | return 0; |
334 | return 0; |
269 | } |
335 | } |
270 | 336 | ||
271 | DLLEXPORT int DRSEnd(){ |
337 | DLLEXPORT int DRSEnd(){ |
272 | 338 | ||
273 | /* delete DRS object -> close USB connection */ |
339 | /* delete DRS object -> close USB connection */ |
274 | if (drs) delete drs; |
340 | if (drs) delete drs; |
275 | drs = NULL; |
341 | drs = NULL; |
276 | return 0; |
342 | return 0; |
277 | } |
343 | } |
278 | 344 | ||
279 | 345 | ||
280 | 346 | ||
281 | DLLEXPORT int DRSToBuffer( unsigned char *p, int m_evSerial ) |
347 | DLLEXPORT int DRSToBuffer( unsigned char *p, int m_evSerial ) |
282 | { |
348 | { |
283 | 349 | ||
284 | unsigned short d; |
350 | unsigned short d; |
285 | float t; |
351 | float t; |
286 | unsigned char *p0 = p; |
352 | unsigned char *p0 = p; |
287 | 353 | ||
288 | int m_nBoards = drs->GetNumberOfBoards(); |
354 | int m_nBoards = drs->GetNumberOfBoards(); |
289 | int m_waveDepth = 1024 ;// 2048 |
355 | int m_waveDepth = 1024 ;// 2048 |
290 | int m_inputRange = drs->GetBoard(0)->GetInputRange(); |
356 | int m_inputRange = drs->GetBoard(0)->GetInputRange(); |
291 | time_t rawtime; |
357 | time_t rawtime; |
292 | time ( &rawtime ); |
358 | time ( &rawtime ); |
293 | struct tm m_evTimestamp; |
359 | struct tm m_evTimestamp; |
294 | m_evTimestamp = *(localtime ( &rawtime )); |
360 | m_evTimestamp = *(localtime ( &rawtime )); |
295 | struct timeval mtime; |
361 | struct timeval mtime; |
296 | gettimeofday(&mtime, NULL); |
362 | gettimeofday(&mtime, NULL); |
297 | 363 | ||
298 | if (m_evSerial == 0) { |
364 | if (m_evSerial == 0) { |
299 | memcpy(p, "DRS2", 4); // File identifier and version |
365 | memcpy(p, "DRS2", 4); // File identifier and version |
300 | p += 4; |
366 | p += 4; |
301 | // time calibration header |
367 | // time calibration header |
302 | memcpy(p, "TIME", 4); |
368 | memcpy(p, "TIME", 4); |
303 | p += 4; |
369 | p += 4; |
304 | for (int b=0 ; b<m_nBoards ; b++) { |
370 | for (int b=0 ; b<m_nBoards ; b++) { |
305 | // store board serial number |
371 | // store board serial number |
306 | sprintf((char *)p, "B#"); |
372 | sprintf((char *)p, "B#"); |
307 | p += 2; |
373 | p += 2; |
308 | *(unsigned short *)p = drs->GetBoard(b)->GetBoardSerialNumber(); |
374 | *(unsigned short *)p = drs->GetBoard(b)->GetBoardSerialNumber(); |
309 | p += sizeof(unsigned short); |
375 | p += sizeof(unsigned short); |
310 | 376 | ||
311 | for (int i=0 ; i<4 ; i++) { |
377 | for (int i=0 ; i<4 ; i++) { |
312 | if (DRSParameters->mask & (0x1<<i)) { |
378 | if (DRSParameters->mask & (0x1<<i)) { |
313 | sprintf((char *)p, "C%03d", i+1); |
379 | sprintf((char *)p, "C%03d", i+1); |
314 | p += 4; |
380 | p += 4; |
315 | float tcal[2048]; |
381 | float tcal[2048]; |
316 | drs->GetBoard(b)->GetTimeCalibration(0, i*2, 0, tcal, 0); |
382 | drs->GetBoard(b)->GetTimeCalibration(0, i*2, 0, tcal, 0); |
317 | for (int j=0 ; j<m_waveDepth ; j++) { |
383 | for (int j=0 ; j<m_waveDepth ; j++) { |
318 | // save binary time as 32-bit float value |
384 | // save binary time as 32-bit float value |
319 | if (m_waveDepth == 2048) { |
385 | if (m_waveDepth == 2048) { |
320 | t = (tcal[j]+tcal[j+1])/2; |
386 | t = (tcal[j]+tcal[j+1])/2; |
321 | j++; |
387 | j++; |
322 | } else |
388 | } else |
323 | t = tcal[j]; |
389 | t = tcal[j]; |
324 | *(float *)p = t; |
390 | *(float *)p = t; |
325 | p += sizeof(float); |
391 | p += sizeof(float); |
326 | } |
392 | } |
327 | } |
393 | } |
328 | } |
394 | } |
329 | } |
395 | } |
330 | } |
396 | } |
331 | 397 | ||
332 | 398 | ||
333 | 399 | ||
334 | memcpy(p, "EHDR", 4); |
400 | memcpy(p, "EHDR", 4); |
335 | p += 4; |
401 | p += 4; |
336 | *(int *)p = m_evSerial; |
402 | *(int *)p = m_evSerial; |
337 | p += sizeof(int); |
403 | p += sizeof(int); |
338 | *(unsigned short *)p = m_evTimestamp.tm_year; |
404 | *(unsigned short *)p = m_evTimestamp.tm_year; |
339 | p += sizeof(unsigned short); |
405 | p += sizeof(unsigned short); |
340 | *(unsigned short *)p = m_evTimestamp.tm_mon; |
406 | *(unsigned short *)p = m_evTimestamp.tm_mon; |
341 | p += sizeof(unsigned short); |
407 | p += sizeof(unsigned short); |
342 | *(unsigned short *)p = m_evTimestamp.tm_mday; |
408 | *(unsigned short *)p = m_evTimestamp.tm_mday; |
343 | p += sizeof(unsigned short); |
409 | p += sizeof(unsigned short); |
344 | *(unsigned short *)p = m_evTimestamp.tm_hour; |
410 | *(unsigned short *)p = m_evTimestamp.tm_hour; |
345 | p += sizeof(unsigned short); |
411 | p += sizeof(unsigned short); |
346 | *(unsigned short *)p = m_evTimestamp.tm_min; |
412 | *(unsigned short *)p = m_evTimestamp.tm_min; |
347 | p += sizeof(unsigned short); |
413 | p += sizeof(unsigned short); |
348 | *(unsigned short *)p = m_evTimestamp.tm_sec; |
414 | *(unsigned short *)p = m_evTimestamp.tm_sec; |
349 | p += sizeof(unsigned short); |
415 | p += sizeof(unsigned short); |
350 | *(unsigned short *)p = mtime.tv_usec/1000; |
416 | *(unsigned short *)p = mtime.tv_usec/1000; |
351 | p += sizeof(unsigned short); |
417 | p += sizeof(unsigned short); |
352 | *(unsigned short *)p = (unsigned short)(m_inputRange * 1000); // range |
418 | *(unsigned short *)p = (unsigned short)(m_inputRange * 1000); // range |
353 | p += sizeof(unsigned short); |
419 | p += sizeof(unsigned short); |
354 | 420 | ||
355 | int b=0; // only for board 0 |
421 | int b=0; // only for board 0 |
356 | 422 | ||
357 | // store board serial number |
423 | // store board serial number |
358 | sprintf((char *)p, "B#"); |
424 | sprintf((char *)p, "B#"); |
359 | p += 2; |
425 | p += 2; |
360 | *(unsigned short *)p = drs->GetBoard(b)->GetBoardSerialNumber(); |
426 | *(unsigned short *)p = drs->GetBoard(b)->GetBoardSerialNumber(); |
361 | p += sizeof(unsigned short); |
427 | p += sizeof(unsigned short); |
362 | 428 | ||
363 | // store trigger cell |
429 | // store trigger cell |
364 | sprintf((char *)p, "T#"); |
430 | sprintf((char *)p, "T#"); |
365 | p += 2; |
431 | p += 2; |
366 | *(unsigned short *)p = drs->GetBoard(b)->GetTriggerCell(DRSParameters->trigger_channel); |
432 | *(unsigned short *)p = drs->GetBoard(b)->GetTriggerCell(DRSParameters->trigger_channel); |
367 | p += sizeof(unsigned short); |
433 | p += sizeof(unsigned short); |
368 | 434 | ||
369 | for (int i=0 ; i<4 ; i++) { |
435 | for (int i=0 ; i<4 ; i++) { |
370 | if (DRSParameters->mask & (0x1<<i)) { |
436 | if (DRSParameters->mask & (0x1<<i)) { |
371 | sprintf((char *)p, "C%03d", i+1); |
437 | sprintf((char *)p, "C%03d", i+1); |
372 | p += 4; |
438 | p += 4; |
373 | unsigned int s = drs->GetBoard(b)->GetScaler(i); |
439 | unsigned int s = drs->GetBoard(b)->GetScaler(i); |
374 | memcpy(p, &s, sizeof(int)); |
440 | memcpy(p, &s, sizeof(int)); |
375 | p += sizeof(int); |
441 | p += sizeof(int); |
376 | for (int j=0 ; j<m_waveDepth ; j++) { |
442 | for (int j=0 ; j<m_waveDepth ; j++) { |
377 | // save binary date as 16-bit value: |
443 | // save binary date as 16-bit value: |
378 | // 0 = -0.5V, 65535 = +0.5V for range 0 |
444 | // 0 = -0.5V, 65535 = +0.5V for range 0 |
379 | // 0 = -0.05V, 65535 = +0.95V for range 0.45 |
445 | // 0 = -0.05V, 65535 = +0.95V for range 0.45 |
380 | if (m_waveDepth == 2048) { |
446 | if (m_waveDepth == 2048) { |
381 | // in cascaded mode, save 1024 values as averages of the 2048 values |
447 | // in cascaded mode, save 1024 values as averages of the 2048 values |
382 | d = (unsigned short)(((DRSWaveArray[i][j]+DRSWaveArray[i][j+1])/2000.0 - m_inputRange + 0.5) * 65535); |
448 | d = (unsigned short)(((DRSWaveArray[i][j]+DRSWaveArray[i][j+1])/2000.0 - m_inputRange + 0.5) * 65535); |
383 | *(unsigned short *)p = d; |
449 | *(unsigned short *)p = d; |
384 | p += sizeof(unsigned short); |
450 | p += sizeof(unsigned short); |
385 | j++; |
451 | j++; |
386 | } else { |
452 | } else { |
387 | d = (unsigned short)((DRSWaveArray[i][j]/1000.0 - m_inputRange + 0.5) * 65535); |
453 | d = (unsigned short)((DRSWaveArray[i][j]/1000.0 - m_inputRange + 0.5) * 65535); |
388 | *(unsigned short *)p = d; |
454 | *(unsigned short *)p = d; |
389 | p += sizeof(unsigned short); |
455 | p += sizeof(unsigned short); |
390 | } |
456 | } |
391 | } |
457 | } |
392 | } |
458 | } |
393 | } |
459 | } |
394 | 460 | ||
395 | return (p-p0); // return number of bytes |
461 | return (p-p0); // return number of bytes |
396 | } |
462 | } |
397 | 463 | ||
398 | 464 | ||
399 | 465 | ||
400 | #ifdef MAIN |
466 | #ifdef MAIN |
401 | 467 | ||
402 | 468 | ||
403 | 469 | ||
404 | #include "XGetopt.h" |
470 | #include "XGetopt.h" |
405 | #include "getopt.h" |
471 | #include "getopt.h" |
406 | 472 | ||
407 | TH2F *h[4]; |
473 | TH2F *h[4]; |
408 | 474 | ||
409 | typedef struct { |
475 | typedef struct { |
410 | char recid[4]; |
476 | char recid[4]; |
411 | unsigned int posx, posy, posz; |
477 | unsigned int posx, posy, posz; |
412 | unsigned int iposx, iposy, iposz; |
478 | unsigned int iposx, iposy, iposz; |
413 | } POSREC; |
479 | } POSREC; |
414 | 480 | ||
415 | 481 | ||
416 | int help() { |
482 | int help() { |
417 | printf ("*********************************************************************************:\n"); |
483 | printf ("*********************************************************************************:\n"); |
418 | printf ("Usage: Read of the DRS4 PSI board and dump of the waveforms in the file:\n\n"); |
484 | printf ("Usage: Read of the DRS4 PSI board and dump of the waveforms in the file:\n\n"); |
419 | printf ("Arguments: \n"); |
485 | printf ("Arguments: \n"); |
420 | printf ("-v verbosity \n"); |
486 | printf ("-v verbosity \n"); |
421 | printf ("-a output rootfile \n"); |
487 | printf ("-a output rootfile \n"); |
422 | printf ("-o output filename \n"); |
488 | printf ("-o output filename \n"); |
423 | printf ("-r range \n"); |
489 | printf ("-r range \n"); |
424 | printf ("-n number of events\n"); |
490 | printf ("-n number of events\n"); |
425 | printf ("-m channel bit mask\n"); |
491 | printf ("-m channel bit mask\n"); |
426 | printf ("-h trigger type (0 software, 1 fast hardware, 2 slow hardware)\n"); |
492 | printf ("-h trigger type (0 software, 1 fast hardware, 2 slow hardware)\n"); |
427 | printf ("-d trigger delay in ns\n"); |
493 | printf ("-d trigger delay in ns\n"); |
428 | printf ("-f sampling frequency\n"); |
494 | printf ("-f sampling frequency\n"); |
429 | printf ("-t trigger channel\n"); |
495 | printf ("-t trigger channel\n"); |
430 | printf ("-l trigger level\n"); |
496 | printf ("-l trigger level\n"); |
431 | printf ("-p trigger polarity (0 positive\n"); |
497 | printf ("-p trigger polarity (0 positive\n"); |
432 | printf ("*********************************************************************************:\n"); |
498 | printf ("*********************************************************************************:\n"); |
433 | printf ("Examples:\n\n"); |
499 | printf ("Examples:\n\n"); |
434 | 500 | ||
435 | return 0; |
501 | return 0; |
436 | } |
502 | } |
437 | 503 | ||
438 | 504 | ||
439 | 505 | ||
440 | char filename[0xFF]=""; |
506 | char filename[0xFF]=""; |
441 | char rootfile[0xFF]=""; |
507 | char rootfile[0xFF]=""; |
442 | int neve = 0; |
508 | int neve = 0; |
443 | int verbose = 0; |
509 | int verbose = 0; |
444 | 510 | ||
445 | void Init(int argc, char **argv){ |
511 | void Init(int argc, char **argv){ |
446 | DRSParameters = drssettings::instance(); |
512 | DRSParameters = drssettings::instance(); |
447 | char c; |
513 | char c; |
448 | 514 | ||
449 | extern char *optarg; |
515 | extern char *optarg; |
450 | extern int optind; |
516 | extern int optind; |
451 | extern int optopt; |
517 | extern int optopt; |
452 | while ((c = getopt (argc, argv, "a:o:v:m:n:f:d:r:h:t:p:l:")) != -1){ |
518 | while ((c = getopt (argc, argv, "a:o:v:m:n:f:d:r:h:t:p:l:")) != -1){ |
453 | 519 | ||
454 | switch (c) |
520 | switch (c) |
455 | { |
521 | { |
456 | 522 | ||
457 | case 'a': |
523 | case 'a': |
458 | sprintf(rootfile,"%s", optarg ); |
524 | sprintf(rootfile,"%s", optarg ); |
459 | break; // root output |
525 | break; // root output |
460 | 526 | ||
461 | case 'o': |
527 | case 'o': |
462 | sprintf(filename,"%s", optarg ); |
528 | sprintf(filename,"%s", optarg ); |
463 | break; // output |
529 | break; // output |
464 | 530 | ||
465 | case 'v': |
531 | case 'v': |
466 | verbose = atoi(optarg); |
532 | verbose = atoi(optarg); |
467 | break; // verbosity |
533 | break; // verbosity |
468 | case 'm':{ |
534 | case 'm':{ |
469 | unsigned long ul = strtoul (optarg,NULL,0); |
535 | unsigned long ul = strtoul (optarg,NULL,0); |
470 | DRSSetMask( (unsigned char)( ul & 0xF ) ) ; |
536 | DRSSetMask( (unsigned char)( ul & 0xF ) ) ; |
471 | break; |
537 | break; |
472 | } // channel mask |
538 | } // channel mask |
473 | case 'n': |
539 | case 'n': |
474 | neve = atoi (optarg); |
540 | neve = atoi (optarg); |
475 | break; // number of events or number of scan points |
541 | break; // number of events or number of scan points |
476 | 542 | ||
477 | case 'f': |
543 | case 'f': |
478 | DRSSetFrequency( atoi (optarg) ); |
544 | DRSSetFrequency( atoi (optarg) ); |
479 | break; // sampling frequency |
545 | break; // sampling frequency |
480 | 546 | ||
481 | case 'd': |
547 | case 'd': |
482 | DRSSetTriggerDelay( atof (optarg) ); |
548 | DRSSetTriggerDelay( atof (optarg) ); |
483 | break; // trigger delay |
549 | break; // trigger delay |
484 | case 'p': |
550 | case 'p': |
485 | DRSSetTriggerPolarity( atoi (optarg)); |
551 | DRSSetTriggerPolarity( atoi (optarg)); |
486 | break; // trigger polarity |
552 | break; // trigger polarity |
487 | case 'l': |
553 | case 'l': |
488 | DRSSetTriggerLevel(atoi (optarg)); |
554 | DRSSetTriggerLevel(atoi (optarg)); |
489 | break; // trigger level |
555 | break; // trigger level |
490 | 556 | ||
491 | 557 | ||
492 | case 'r': |
558 | case 'r': |
493 | DRSSetRange ( atof (optarg) ); |
559 | DRSSetRange ( atof (optarg) ); |
494 | break; // range |
560 | break; // range |
495 | case 'h': |
561 | case 'h': |
496 | DRSSetTriggerType( atoi (optarg) ); |
562 | DRSSetTriggerType( atoi (optarg) ); |
497 | break; // send sotware trigger before reading out the dat |
563 | break; // send sotware trigger before reading out the dat |
498 | case 't': |
564 | case 't': |
499 | DRSSetTriggerChannel( atoi(optarg) ); |
565 | DRSSetTriggerChannel( atoi(optarg) ); |
500 | break; // trigger channel |
566 | break; // trigger channel |
501 | 567 | ||
502 | 568 | ||
503 | case '?': |
569 | case '?': |
504 | if (optopt == 'c') |
570 | if (optopt == 'c') |
505 | fprintf (stderr, "Option -%c requires an argument.\n", optopt); |
571 | fprintf (stderr, "Option -%c requires an argument.\n", optopt); |
506 | else if (isprint (optopt)) |
572 | else if (isprint (optopt)) |
507 | fprintf (stderr, "Unknown option `-%c'.\n", optopt); |
573 | fprintf (stderr, "Unknown option `-%c'.\n", optopt); |
508 | else |
574 | else |
509 | fprintf (stderr, |
575 | fprintf (stderr, |
510 | "Unknown option character `\\x%x'.\n", |
576 | "Unknown option character `\\x%x'.\n", |
511 | optopt); |
577 | optopt); |
512 | abort (); |
578 | abort (); |
513 | default: |
579 | default: |
514 | abort (); |
580 | abort (); |
515 | } |
581 | } |
516 | } |
582 | } |
517 | //for (int i=optind; i<argc; i++) data = strtoul (argv[i],NULL,0); |
583 | //for (int i=optind; i<argc; i++) data = strtoul (argv[i],NULL,0); |
518 | 584 | ||
519 | } |
585 | } |
520 | 586 | ||
521 | int ctrl_c=0; |
587 | int ctrl_c=0; |
522 | DLLEXPORT void DRSSigInt ( int ) |
588 | DLLEXPORT void DRSSigInt ( int ) |
523 | { |
589 | { |
524 | ctrl_c = 1; |
590 | ctrl_c = 1; |
525 | printf("->>> CTRL+c !!!\n"); |
591 | printf("->>> CTRL+c !!!\n"); |
526 | } |
592 | } |
527 | 593 | ||
528 | //#ifdef __CINT__ |
594 | //#ifdef __CINT__ |
529 | int main(int argc, char **argv){ |
595 | int main(int argc, char **argv){ |
530 | //#else |
596 | //#else |
531 | //int drsread(int argc, char **argv){ |
597 | //int drsread(int argc, char **argv){ |
532 | //#endif |
598 | //#endif |
533 | 599 | ||
534 | if (signal (SIGINT, DRSSigInt) == SIG_ERR) { |
600 | if (signal (SIGINT, DRSSigInt) == SIG_ERR) { |
535 | perror ("sigignore"); |
601 | perror ("sigignore"); |
536 | } |
602 | } |
537 | 603 | ||
538 | 604 | ||
539 | Init(argc, argv); |
605 | Init(argc, argv); |
540 | if (argc==1) { help(); return 0; } |
606 | if (argc==1) { help(); return 0; } |
541 | 607 | ||
542 | FILE *fp=NULL; |
608 | FILE *fp=NULL; |
543 | if (strlen(filename)>0) { |
609 | if (strlen(filename)>0) { |
544 | if (verbose) printf("Data in the file:%s\n", filename); |
610 | if (verbose) printf("Data in the file:%s\n", filename); |
545 | fp=fopen(filename,"wb"); |
611 | fp=fopen(filename,"wb"); |
546 | } |
612 | } |
547 | 613 | ||
548 | TFile *rfile= NULL; |
614 | TFile *rfile= NULL; |
549 | if (strlen(rootfile)>0) { |
615 | if (strlen(rootfile)>0) { |
550 | if (verbose) printf("Data in the file:%s\n", rootfile); |
616 | if (verbose) printf("Data in the file:%s\n", rootfile); |
551 | rfile = new TFile(rootfile,"RECREATE"); |
617 | rfile = new TFile(rootfile,"RECREATE"); |
552 | } |
618 | } |
553 | 619 | ||
554 | 620 | ||
555 | TCanvas *c = new TCanvas(); c->Divide(2,2); |
621 | TCanvas *c = new TCanvas(); c->Divide(2,2); |
556 | c->Draw(); |
622 | c->Draw(); |
557 | for (int i=0;i<4;i++){ |
623 | for (int i=0;i<4;i++){ |
558 | if (! (DRSParameters->mask & ( 0x1<<i )) ) continue; |
624 | if (! (DRSParameters->mask & ( 0x1<<i )) ) continue; |
559 | char name[0xff]; |
625 | char name[0xff]; |
560 | sprintf(name,"h%d",i); |
626 | sprintf(name,"h%d",i); |
561 | h[i]=new TH2F(name,name,1024,0,204,1024,-0.6+DRSParameters->range,0.6+DRSParameters->range); |
627 | h[i]=new TH2F(name,name,1024,0,204,1024,-0.6+DRSParameters->range,0.6+DRSParameters->range); |
562 | c->cd(i+1); h[i]->Draw("colz"); |
628 | c->cd(i+1); h[i]->Draw("colz"); |
563 | 629 | ||
564 | } |
630 | } |
565 | 631 | ||
566 | 632 | ||
567 | 633 | ||
568 | //--------------------------------------- |
634 | //--------------------------------------- |
569 | static unsigned char *buffer; |
635 | static unsigned char *buffer; |
570 | static int buffer_size = 0; |
636 | static int buffer_size = 0; |
571 | const int nBoards=1; |
637 | const int nBoards=1; |
572 | const int waveDepth=1024; |
638 | const int waveDepth=1024; |
573 | if (buffer_size == 0) { |
639 | if (buffer_size == 0) { |
574 | buffer_size = 4 + nBoards * (4 + 4*(4+waveDepth*4)); |
640 | buffer_size = 4 + nBoards * (4 + 4*(4+waveDepth*4)); |
575 | buffer_size += 24 + nBoards * (8 + 4*(4+waveDepth*2)); |
641 | buffer_size += 24 + nBoards * (8 + 4*(4+waveDepth*2)); |
576 | buffer = (unsigned char *)malloc(buffer_size); |
642 | buffer = (unsigned char *)malloc(buffer_size); |
577 | } |
643 | } |
578 | 644 | ||
579 | time_t t,told, tstart; |
645 | time_t t,told, tstart; |
580 | if (!DRSInit()){ |
646 | if (!DRSInit()){ |
581 | time(&tstart); |
647 | time(&tstart); |
582 | told=tstart; |
648 | told=tstart; |
583 | int i=0; |
649 | int i=0; |
584 | for (i=0; i<neve; i++) { |
650 | for (i=0; i<neve; i++) { |
585 | int nb = (DRSRead(1) == 0 && fp ) ? DRSToBuffer( buffer , i ) : 0; |
651 | int nb = (DRSRead(1) == 0 && fp ) ? DRSToBuffer( buffer , i ) : 0; |
586 | 652 | ||
587 | if (DRSTimeout) i--; |
653 | if (DRSTimeout) i--; |
588 | if (ctrl_c) break; |
654 | if (ctrl_c) break; |
589 | time(&t); |
655 | time(&t); |
590 | if (t!=told ) { |
656 | if (t!=told ) { |
591 | printf("%d events in %2.2f min (%d s) %s",i+1, (double)(t-tstart)/60.,int(t-tstart), ctime(&t)); |
657 | printf("%d events in %2.2f min (%d s) %s",i+1, (double)(t-tstart)/60.,int(t-tstart), ctime(&t)); |
592 | c->Modified(); c->Update(); |
658 | c->Modified(); c->Update(); |
593 | } |
659 | } |
594 | told=t; |
660 | told=t; |
595 | // Save data |
661 | // Save data |
596 | if (nb>0 && fp) fwrite(buffer, 1,nb ,fp); |
662 | if (nb>0 && fp) fwrite(buffer, 1,nb ,fp); |
597 | // Plot Data |
663 | // Plot Data |
598 | for (int k=0;k<4;k++){ |
664 | for (int k=0;k<4;k++){ |
599 | if (! (DRSParameters->mask & ( 0x1<<k )) ) continue; |
665 | if (! (DRSParameters->mask & ( 0x1<<k )) ) continue; |
600 | float *t=DRSGetTime(k); |
666 | float *t=DRSGetTime(k); |
601 | float *x=DRSGetWave(k); |
667 | float *x=DRSGetWave(k); |
602 | for (int i=0 ; i<1024 ; i++) { |
668 | for (int i=0 ; i<1024 ; i++) { |
603 | if (verbose) printf("[%d] %d. x= %3.2f y=%3.2f\n", k, i, t[i], x[i] ); |
669 | if (verbose) printf("[%d] %d. x= %3.2f y=%3.2f\n", k, i, t[i], x[i] ); |
604 | h[k]->Fill( t[i], x[i]*1e-3); |
670 | h[k]->Fill( t[i], x[i]*1e-3); |
605 | } |
671 | } |
606 | } |
672 | } |
607 | } |
673 | } |
608 | time(&t); |
674 | time(&t); |
609 | printf("%d events in %2.2f min (%d s) %s",i+1, (double)(t-tstart)/60.,int(t-tstart), ctime(&t)); |
675 | printf("%d events in %2.2f min (%d s) %s",i+1, (double)(t-tstart)/60.,int(t-tstart), ctime(&t)); |
610 | 676 | ||
611 | DRSEnd(); |
677 | DRSEnd(); |
612 | } |
678 | } |
613 | //--------------------------------------- |
679 | //--------------------------------------- |
614 | if (rfile !=NULL) rfile->Write(); |
680 | if (rfile !=NULL) rfile->Write(); |
615 | if (fp) fclose(fp); |
681 | if (fp) fclose(fp); |
616 | if (c) c->SaveAs("drsread.pdf"); |
682 | if (c) c->SaveAs("drsread.pdf"); |
617 | // TApplication* theApp = new TApplication("App", NULL, NULL); |
683 | // TApplication* theApp = new TApplication("App", NULL, NULL); |
618 | // theApp->Run(); |
684 | // theApp->Run(); |
619 | 685 | ||
620 | 686 | ||
621 | 687 | ||
622 | } |
688 | } |
623 | 689 | ||
624 | #endif |
690 | #endif |
625 | 691 |