Mantid
Loading...
Searching...
No Matches
isisraw.cpp
Go to the documentation of this file.
1// Mantid Repository : https://github.com/mantidproject/mantid
2//
3// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
4// NScD Oak Ridge National Laboratory, European Spallation Source,
5// Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
6// SPDX - License - Identifier: GPL - 3.0 +
7#include "isisraw.h"
8#include "MantidKernel/Logger.h"
9#include "byte_rel_comp.h"
10#include "vms_convert.h"
11
12#include <algorithm>
13#include <cstdio>
14#include <ostream>
15
16#define SUCCESS 0
17#define FAILURE 1
18
19namespace {
20Mantid::Kernel::Logger logger("isisraw");
21}
23ISISRAW::ISISRAW() : m_crpt(nullptr), dat1(nullptr) {
24 int i, j;
25 // section 1
26 frmt_ver_no = 2; // format version number VER1 (=2)
27 data_format = 0; // data section format (0 = by TC, 1 = by spectrum)
28 // section 2
29 ver2 = 1; // run section version number VER2 (=1)
30 r_number = 0; // run number
31 memset(r_title, ' ', sizeof(r_title)); // run title
32 // section 3
33 ver3 = 2; // instrument section version number (=2)
34 memset(i_inst, ' ', sizeof(i_inst)); // instrument name
35 i_det = 1; // number of detectors NDET
36 i_mon = 1; // number of monitors NMON
37 i_use = 1; // number of user defined UTn tables NUSE
38 // I_TABLES is address of MDET
39 mdet = new int[i_mon]; // detector number for monitors (size NMON)
40 monp = new int[i_mon]; // prescale value for each monitor (size NMON)
41 for (i = 0; i < i_mon; i++) {
42 mdet[i] = i + 1;
43 monp[i] = 1;
44 }
45 spec = new int[i_det]; // spectrum number table (size NDET)
46 delt = new float[i_det]; // hold off table (size NDET)
47 len2 = new float[i_det]; // L2 table (size NDET)
48 code = new int[i_det]; // code for UTn tables (size NDET)
49 tthe = new float[i_det]; // 2theta scattering angle (size NDET)
50 ut = new float[i_use * i_det]; // nuse UT* user tables (total size NUSE*NDET) ut01=phi
51 for (i = 0; i < i_det; i++) {
52 spec[i] = i + 1; // we have t_nsp1 = i_det
53 delt[i] = static_cast<float>(i);
54 len2[i] = static_cast<float>(i);
55 code[i] = i + 1;
56 tthe[i] = static_cast<float>(i);
57 }
58 for (i = 0; i < i_use; i++) {
59 for (j = 0; j < i_det; j++) {
60 ut[i * i_det + j] = static_cast<float>(j);
61 }
62 }
63 // section 4
64 ver4 = 2; // SE section version number (=2)
65 e_nse = 1; // number of controlled SEPs NSEP
66 e_seblock = new SE_STRUCT[e_nse]; // NSEP SE parameter blocks (total size
67 // NSEP*32*4 bytes)
68 // section 5
69 ver5 = 2; // DAE section version number (=2)
70 crat = new int[i_det]; // crate number for each detector (size NDET)
71 modn = new int[i_det]; // module number for each detector (size NDET)
72 mpos = new int[i_det]; // module position for each detector (size NDET)
73 timr = new int[i_det]; // time regime for each detector (size NDET)
74 udet = new int[i_det]; // user detector number for each detector (size NDET)
75 for (i = 0; i < i_det; i++) {
76 crat[i] = 1;
77 modn[i] = 1;
78 mpos[i] = i;
79 timr[i] = 1;
80 udet[i] = i;
81 }
82 // section 6
83 ver6 = 1; // TCB section version number (=1)
84 t_ntrg = 1; // number of time regimes (=1)
85 t_nfpp = 1; // number of frames per period
86 t_nper = 1; // number of periods
87 for (i = 0; i < 256; i++) {
88 t_pmap[i] = 1; // period number for each basic period
89 }
90 t_nsp1 = i_det; // number of spectra in time regime 1
91 t_ntc1 = 10; // number of time channels in time regime 1
92 memset(t_tcm1, 0, sizeof(t_tcm1)); // time channel mode
93 memset(t_tcp1, 0, sizeof(t_tcp1)); // time channel parameters
94 t_pre1 = 1; // prescale for 32MHz clock
95 t_tcb1 = new int[t_ntc1 + 1]; // time channel boundaries in clock pulses (size NTC1+1)
96 for (i = 0; i < t_ntc1 + 1; i++) {
97 t_tcb1[i] = i;
98 }
99 // section 7
100 // write NCHAN = NTC1+1 time channel boundaries
101 ver7 = 1; // user version number (=1)
102 u_len = 1;
103 u_dat = new float[u_len]; // user defined data (ULEN, max size 400 words)
104 for (i = 0; i < u_len; i++) {
105 u_dat[i] = static_cast<float>(i);
106 }
107 // section 8
108 ver8 = 2; // data version number (=2)
109 // D_DATA points at ddes
110 ddes = new DDES_STRUCT[(t_nsp1 + 1) * t_nper]; // (NSP1+1)*NPER items, totoal
111 // size (NSP1+1)*NPER*2*4 bytes
112 dat1 = new uint32_t[(t_ntc1 + 1) * (t_nsp1 + 1) * t_nper]; // compressed data for (NTC1+1)*(NSP1+1)*NPER values
113 for (i = 0; i < (t_ntc1 + 1) * (t_nsp1 + 1) * t_nper; i++) {
114 dat1[i] = i;
115 }
116#if defined(_WIN32)
117// disable warning about strcpy
118#pragma warning(disable : 4996)
119#endif
120 logsect.nlines = 1;
121 logsect.lines = new LOG_LINE[logsect.nlines];
122 for (i = 0; i < logsect.nlines; i++) {
123 logsect.lines[i].data = reinterpret_cast<char *>(malloc(16));
124 strcpy(logsect.lines[i].data, "test log line");
125 logsect.lines[i].len = static_cast<int>(strlen(logsect.lines[i].data));
126 }
127 addItems();
128}
129
131int ISISRAW::addItems() {
132 static const int hdr_size = sizeof(hdr) / sizeof(char);
133 static const int rrpb_size = sizeof(rpb) / sizeof(float);
134 static const int irpb_size = sizeof(rpb) / sizeof(int);
135 m_char_items.addItem("HDR", reinterpret_cast<const char *>(&hdr), false, &hdr_size);
136 m_real_items.addItem("RRPB", reinterpret_cast<float *>(&rpb), false, &rrpb_size);
137 m_int_items.addItem("IRPB", reinterpret_cast<int *>(&rpb), false, &irpb_size);
138 return 0;
139}
140
141// create one bound to a CRPT
143ISISRAW::ISISRAW(ISISCRPT_STRUCT *crpt)
144 : m_crpt(crpt), frmt_ver_no(0), data_format(0), ver2(0), r_number(0), ver3(0), i_det(0), i_mon(0), i_use(0),
145 mdet(nullptr), monp(nullptr), spec(nullptr), delt(nullptr), len2(nullptr), code(nullptr), tthe(nullptr),
146 ut(nullptr), ver4(0), ver5(0), crat(nullptr), modn(nullptr), mpos(nullptr), timr(nullptr), udet(nullptr), ver6(0),
147 t_ntrg(0), t_nfpp(0), t_nper(0), t_nsp1(0), t_ntc1(0), t_pre1(0), t_tcb1(nullptr), ver7(0), u_dat(nullptr),
148 ver8(0), ddes(nullptr), dat1(nullptr) {
149 memset(r_title, ' ', sizeof(r_title));
150 memset(i_inst, ' ', sizeof(i_inst));
151 std::fill(std::begin(t_pmap), std::end(t_pmap), 1); // period number for each basic period
152 memset(t_tcm1, 0, sizeof(t_tcm1)); // time channel mode
153 memset(t_tcp1, 0, sizeof(t_tcp1)); // time channel parameters
154 e_nse = 0;
155 e_seblock = nullptr;
156 u_len = 0;
157 logsect.nlines = 0;
158 logsect.lines = nullptr;
159 addItems();
160 updateFromCRPT();
161}
162
163// create one bound to a CRPT
165ISISRAW::ISISRAW(ISISCRPT_STRUCT *crpt, bool doUpdateFromCRPT)
166 : m_crpt(crpt), frmt_ver_no(0), data_format(0), ver2(0), r_number(0), ver3(0), i_det(0), i_mon(0), i_use(0),
167 mdet(nullptr), monp(nullptr), spec(nullptr), delt(nullptr), len2(nullptr), code(nullptr), tthe(nullptr),
168 ut(nullptr), ver4(0), ver5(0), crat(nullptr), modn(nullptr), mpos(nullptr), timr(nullptr), udet(nullptr), ver6(0),
169 t_ntrg(0), t_nfpp(0), t_nper(0), t_nsp1(0), t_ntc1(0), t_pre1(0), t_tcb1(nullptr), ver7(0), u_dat(nullptr),
170 ver8(0), ddes(nullptr), dat1(nullptr) {
171 memset(r_title, ' ', sizeof(r_title));
172 memset(i_inst, ' ', sizeof(i_inst));
173 std::fill(std::begin(t_pmap), std::end(t_pmap), 1); // period number for each basic period
174 memset(t_tcm1, 0, sizeof(t_tcm1)); // time channel mode
175 memset(t_tcp1, 0, sizeof(t_tcp1)); // time channel parameters
176 e_nse = 0;
177 e_seblock = nullptr;
178 u_len = 0;
179 logsect.nlines = 0;
180 logsect.lines = nullptr;
181 addItems();
182 if (doUpdateFromCRPT) {
183 updateFromCRPT();
184 }
185}
186
187// update from bound CRPT
189int ISISRAW::updateFromCRPT() {
190 if (m_crpt == nullptr) {
191 return 0;
192 }
193#ifndef REAL_CRPT
194 return 0;
195#else
196 int i;
197 char buffer[256];
198 spacePadCopy(hdr.inst_abrv, m_crpt->inst_abrv, sizeof(hdr.inst_abrv));
199 sprintf(buffer, "%05d", m_crpt->run_number);
200 spacePadCopy(hdr.hd_run, buffer, sizeof(hdr.hd_run));
201 spacePadCopy(hdr.hd_user, m_crpt->user_name, sizeof(hdr.hd_user));
202 // spacePadCopy(hdr.hd_title, m_crpt->short_title, sizeof(hdr.hd_title));
203 spacePadCopy(hdr.hd_title, m_crpt->long_title, sizeof(hdr.hd_title));
204 vmstime(buffer, sizeof(buffer), m_crpt->start_time);
205 spacePadCopy(hdr.hd_date, buffer, sizeof(hdr.hd_date) + sizeof(hdr.hd_time));
206 sprintf(buffer, "%8.2f", m_crpt->good_uamph);
207 spacePadCopy(hdr.hd_dur, buffer, sizeof(hdr.hd_dur));
208
209 // section 1
210 frmt_ver_no = 2; // format version number VER1 (=2)
211 data_format = 0; // data section format (0 = by TC, 1 = by spectrum)
212 // section 2
213 ver2 = 1; // run section version number VER2 (=1)
214 r_number = m_crpt->run_number; // run number
215 spacePadCopy(r_title, m_crpt->long_title, sizeof(r_title)); // run title
216 spacePadCopy(user.r_user, m_crpt->user_name, sizeof(user.r_user));
217 spacePadCopy(user.r_instit, m_crpt->institute, sizeof(user.r_instit));
218 // rpb
219 rpb.r_dur = m_crpt->duration;
220 rpb.r_durunits = 1; // seconds
221 rpb.r_freq = 1; // 50Hz
222 rpb.r_gd_prtn_chrg = m_crpt->good_uamph;
223 rpb.r_tot_prtn_chrg = m_crpt->total_uamph;
224 rpb.r_goodfrm = m_crpt->good_frames;
225 rpb.r_rawfrm = m_crpt->total_frames;
226 rpb.r_dur_secs = m_crpt->duration;
227 // TODO
228 rpb.r_mon_sum1 = 0; // m_crpt->monitor_sum[0];
229 rpb.r_mon_sum2 = 0;
230 rpb.r_mon_sum3 = 0;
231 vmstime(buffer, sizeof(buffer), m_crpt->stop_time);
232 spacePadCopy(rpb.r_enddate, buffer, sizeof(rpb.r_enddate) + sizeof(rpb.r_endtime));
233 rpb.r_prop = m_crpt->rb_number;
234
235 // section 3
236 ver3 = 2; // instrument section version number (=2)
237 spacePadCopy(i_inst, m_crpt->inst_name, sizeof(i_inst)); // instrument name
238 ivpb.i_l1 = m_crpt->i_l1;
239 if (!strcmp(m_crpt->beamstop_position, "IN")) {
240 ivpb.i_bestop = 0;
241 } else {
242 ivpb.i_bestop = 1;
243 }
244 ivpb.i_xsect = m_crpt->aperture1;
245 ivpb.i_ysect = m_crpt->aperture2;
246 ivpb.i_sddist = m_crpt->sdd;
247
248 ivpb.i_foeang = m_crpt->foe_mirror_angle;
249 ivpb.i_xcen = m_crpt->beam_centre_x;
250 ivpb.i_ycen = m_crpt->beam_centre_y;
251 ivpb.i_chopsiz = m_crpt->chopper_opening_angle;
252 ivpb.i_aofi = m_crpt->angle_of_incidence;
253
254 spb.e_phi = m_crpt->sample_phi_angle;
255 spb.e_height = m_crpt->sample_height;
256 spb.e_width = m_crpt->sample_width;
257 spb.e_thick = m_crpt->sample_thickness;
258 if (!stricmp(m_crpt->sample_type, "sample+can")) {
259 spb.e_type = 1;
260 } else if (!stricmp(m_crpt->sample_type, "empty can")) {
261 spb.e_type = 2;
262 } else if (!stricmp(m_crpt->sample_type, "vanadium")) {
263 spb.e_type = 3;
264 } else if (!stricmp(m_crpt->sample_type, "absorber")) {
265 spb.e_type = 4;
266 } else if (!stricmp(m_crpt->sample_type, "nothing")) {
267 spb.e_type = 5;
268 } else if (!stricmp(m_crpt->sample_type, "sample, no can")) {
269 spb.e_type = 6;
270 } else {
271 spb.e_type = 1;
272 }
273
274 if (!stricmp(m_crpt->sample_geometry, "cylinder") || !stricmp(m_crpt->sample_geometry, "cylindrical")) {
275 spb.e_geom = 1;
276 } else if (!stricmp(m_crpt->sample_geometry, "flat plate")) {
277 spb.e_geom = 2;
278 } else if (!stricmp(m_crpt->sample_geometry, "disc")) {
279 spb.e_geom = 3;
280 } else if (!stricmp(m_crpt->sample_geometry, "single crystal")) {
281 spb.e_geom = 4;
282 } else {
283 spb.e_geom = 1;
284 }
285
286 i_det = m_crpt->ndet; // number of detectors NDET
287 i_mon = m_crpt->nmon; // number of monitors NMON
288 i_use = m_crpt->nuse; // number of user defined UTn tables NUSE
289 // I_TABLES is address of MDET
290 mdet = m_crpt->mdet; // detector number for monitors (size NMON)
291 monp = m_crpt->monp; // prescale value for each monitor (size NMON)
292 spec = m_crpt->spec; // spectrum number table (size NDET)
293 delt = m_crpt->delt; // hold off table (size NDET)
294 len2 = m_crpt->len2; // L2 table (size NDET)
295 code = m_crpt->code; // code for UTn tables (size NDET)
296 tthe = m_crpt->tthe; // 2theta scattering angle (size NDET)
297 ut = (float *)m_crpt->ut; // nuse UT* user tables (total size NUSE*NDET) ut01=phi
298
299 // section 4
300 ver4 = 2; // SE section version number (=2)
301 e_nse = 1; // number of controlled SEPs NSEP
302 delete[] e_seblock;
303 e_seblock = new SE_STRUCT[e_nse]; // NSEP SE parameter blocks (total size
304 // NSEP*32*4 bytes)
305 // section 5
306 ver5 = 2; // DAE section version number (=2)
307 daep.a_pars = 4; // 32bit dae memory
308 daep.mem_size = daep.a_pars * (m_crpt->nsp1 + 1) * (m_crpt->ntc1 + 1) * m_crpt->nper_daq;
309
310 daep.ppp_good_high = m_crpt->good_ppp_high;
311 daep.ppp_good_low = m_crpt->good_ppp_low;
312 daep.ppp_raw_high = m_crpt->total_ppp_high;
313 daep.ppp_raw_low = m_crpt->total_ppp_low;
314 daep.mon1_detector = 0; // m_crpt->udet[m_crpt->mdet[0] - 1];
315 daep.mon1_module = 0;
316 daep.mon1_crate = 0;
317 daep.mon1_mask = 0;
318 daep.mon2_detector = 0;
319 daep.mon2_module = 0;
320 daep.mon2_crate = 0;
321 daep.mon2_mask = 0;
322 daep.a_smp = (m_crpt->vetos[SMPVeto].enabled != 0);
323 daep.ext_vetos[0] = (m_crpt->vetos[Ext0Veto].enabled != 0);
324 daep.ext_vetos[1] = (m_crpt->vetos[Ext1Veto].enabled != 0);
325 daep.ext_vetos[2] = (m_crpt->vetos[Ext2Veto].enabled != 0);
326 daep.a_delay = m_crpt->tcb_delay / 4;
327 if (m_crpt->tcb_sync == FrameSyncInternalTest) {
328 daep.a_sync = 1;
329 } else {
330 daep.a_sync = 0; // external
331 }
332 // two time regime mods
333 if (m_crpt->ntrg > 1) {
334 daep.n_tr_shift = m_crpt->ntrg;
335 for (i = 0; i < m_crpt->ntrg; i++) {
336 daep.tr_shift[i] = m_crpt->tcb_trdelay[i];
337 }
338 } else {
339 daep.n_tr_shift = 0;
340 }
341 crat = m_crpt->crat; // crate number for each detector (size NDET)
342 modn = m_crpt->modn; // module number for each detector (size NDET)
343 mpos = m_crpt->mpos; // module position for each detector (size NDET)
344 timr = m_crpt->timr; // time regime for each detector (size NDET)
345 udet = m_crpt->udet; // user detector number for each detector (size NDET)
346 // section 6
347 ver6 = 1; // TCB section version number (=1)
348 t_ntrg = 1; // number of time regimes (=1)
349 t_nfpp = 1; // number of frames per period
350 t_nper = m_crpt->nper_daq; // number of periods
351 for (i = 0; i < 256; i++) {
352 t_pmap[i] = 1; // period number for each basic period
353 }
354 t_nsp1 = m_crpt->nsp1; // number of spectra in time regime 1
355 t_ntc1 = m_crpt->ntc1; // number of time channels in time regime 1
356 // TODO
357 memset(t_tcm1, 0, sizeof(t_tcm1)); // time channel mode
358 memset(t_tcp1, 0, sizeof(t_tcp1)); // time channel parameters
359 t_pre1 = 1; // prescale for 32MHz clock
360 t_tcb1 = m_crpt->tcb1; // time channel boundaries in clock pulses (size NTC1+1)
361 // section 7
362 // write NCHAN = NTC1+1 time channel boundaries
363 ver7 = 1; // user version number (=1)
364 u_len = 1;
365 delete[] u_dat;
366 u_dat = new float[u_len]; // user defined data (ULEN, max size 400 words)
367 for (i = 0; i < u_len; i++) {
368 u_dat[i] = (float)i;
369 }
370 // section 8
371 ver8 = 2; // data version number (=2)
372 // D_DATA points at ddes
373 if ((t_nsp1 != m_nsp1) || (t_nper != m_nper)) {
374 delete[] ddes;
375 ddes = new DDES_STRUCT[(t_nsp1 + 1) * t_nper]; // (NSP1+1)*NPER items,
376 // totoal size
377 // (NSP1+1)*NPER*2*4 bytes
378 }
379 dat1 = (uint32_t *)m_crpt->raw_data;
380 if (m_crpt->log_nlines > 0) {
381 logsect.nlines = m_crpt->log_nlines;
382 delete[] logsect.lines;
383 logsect.lines = new LOG_LINE[logsect.nlines];
384 for (i = 0; i < logsect.nlines; i++) {
385 logsect.lines[i].data = &(m_crpt->log_data[i][0]);
386 logsect.lines[i].len = strlen(logsect.lines[i].data);
387 }
388 } else {
389 logsect.nlines = 0;
390 logsect.lines = NULL;
391 }
392 // for caching on updates
393 m_ntc1 = t_ntc1;
394 m_nsp1 = t_nsp1;
395 m_nper = t_nper;
396 return 0;
397#endif /* REAL_CRPT */
398}
399
401int ISISRAW::ioRAW(FILE *file, bool from_file, bool read_data) {
402 int ndata, len_log, i;
403 fpos_t add_pos, dhdr_pos, keep_pos;
404 if (!from_file) {
405 add.ad_run = 32;
406 add.ad_inst = add.ad_run + 94;
407 add.ad_se = add.ad_inst + 70 + 2 * i_mon + (5 + i_use) * i_det;
408 add.ad_dae = add.ad_se + 66 + e_nse * 32;
409 add.ad_tcb = add.ad_dae + 65 + 5 * i_det;
410 add.ad_user = add.ad_tcb + 288 + (t_ntc1 + 1);
411 add.ad_data = add.ad_user + 2 + u_len;
412 add.ad_log = 0; // we don't know it yet
413 add.ad_end = 0;
414 }
415 ioRAW(file, &hdr, 1, from_file);
416 ioRAW(file, &frmt_ver_no, 1, from_file);
417 fgetpos(file, &add_pos);
418 ioRAW(file, &add, 1, from_file);
419 ioRAW(file, &data_format, 3, from_file);
420 ioRAW(file, r_title, 80, from_file);
421 ioRAW(file, &user, 1, from_file);
422 ioRAW(file, &rpb, 1, from_file);
423 ioRAW(file, &ver3, 1, from_file);
424 ioRAW(file, i_inst, 8, from_file);
425 ioRAW(file, &ivpb, 1, from_file);
426 ioRAW(file, &i_det, 3, from_file);
427 ioRAW(file, &mdet, i_mon, from_file);
428 ioRAW(file, &monp, i_mon, from_file);
429 ioRAW(file, &spec, i_det, from_file);
430 ioRAW(file, &delt, i_det, from_file);
431 ioRAW(file, &len2, i_det, from_file);
432 ioRAW(file, &code, i_det, from_file);
433 ioRAW(file, &tthe, i_det, from_file);
434 ioRAW(file, &ut, i_use * i_det, from_file);
435 ioRAW(file, &ver4, 1, from_file);
436 ioRAW(file, &spb, 1, from_file);
437 ioRAW(file, &e_nse, 1, from_file);
438 ioRAW(file, &e_seblock, e_nse, from_file);
439 ioRAW(file, &ver5, 1, from_file);
440 ioRAW(file, &daep, 1, from_file);
441 ioRAW(file, &crat, i_det, from_file);
442 ioRAW(file, &modn, i_det, from_file);
443 ioRAW(file, &mpos, i_det, from_file);
444 ioRAW(file, &timr, i_det, from_file);
445 ioRAW(file, &udet, i_det, from_file);
446 ioRAW(file, &ver6, 267, from_file);
447 ioRAW(file, &(t_tcp1[0][0]), 20, from_file);
448 ioRAW(file, &t_pre1, 1, from_file);
449 ioRAW(file, &t_tcb1, t_ntc1 + 1, from_file);
450 ioRAW(file, &ver7, 1, from_file);
451 // it appear that the VMS ICP traditionally sets u_len to 1 regardless
452 // of its real size; thus we cannot rely on it for reading and must instead
453 // use section offsets
454 i = 0;
455 ioRAW(file, &i, 1, from_file);
456 // ioRAW(file, &u_len, 1, from_file);
457 if (from_file) {
458 u_len = add.ad_data - add.ad_user - 2;
459
460 if (u_len < 0 || (add.ad_data < add.ad_user + 2)) {
461 // this will/would be used for memory allocation
462 logger.error() << "Error in u_len value read from file, it would be " << u_len
463 << "; where it is calculated as "
464 "u_len = ad_data - ad_user - 2, where ad_data: "
465 << add.ad_data << ", ad_user: " << add.ad_user << '\n';
466 return 0;
467 }
468 }
469
470 ioRAW(file, &u_dat, u_len, from_file);
471 ioRAW(file, &ver8, 1, from_file);
472 fgetpos(file, &dhdr_pos);
473 ioRAW(file, &dhdr, 1, from_file);
474 int ndes;
475 if (!read_data) {
476 ndes = ndata = 0;
477 dat1 = nullptr;
478 // seek to position right after the data if we want to read the log
479 if (from_file) {
480 ndes = t_nper * (t_nsp1 + 1);
481 ioRAW(file, &ddes, ndes, from_file);
482 for (i = 0; i < ndes; i++) {
483 int zero = fseek(file, 4 * ddes[i].nwords, SEEK_CUR);
484 if (0 != zero)
485 logger.error() << "Failed to seek position in file for index: " << i << "\n";
486 }
487 }
488 } else if (dhdr.d_comp == 0) {
489 ndata = t_nper * (t_nsp1 + 1) * (t_ntc1 + 1);
490 ndes = 0;
491 ioRAW(file, &dat1, ndata, from_file);
492 } else {
493 const int outbuff_size = 100000;
494 auto outbuff = new char[outbuff_size];
495 ndata = 0;
496 ndes = t_nper * (t_nsp1 + 1);
497 int nwords;
498 ioRAW(file, &ddes, ndes, from_file);
499 if (from_file) {
500 dat1 = new uint32_t[ndes * (t_ntc1 + 1)];
501 }
502 int offset = 33 + ndes * 2;
503 memset(outbuff, 0,
504 outbuff_size); // so when we round up words we get a zero written
505 for (i = 0; i < ndes; i++) {
506 if (from_file) {
507 nwords = ddes[i].nwords;
508 ioRAW(file, outbuff, 4 * nwords, from_file);
509 byte_rel_expn(outbuff, 4 * nwords, 0, reinterpret_cast<int *>(&dat1[i * (t_ntc1 + 1)]), t_ntc1 + 1);
510 } else {
511 int nout;
512 byte_rel_comp(reinterpret_cast<int *>(&dat1[i * (t_ntc1 + 1)]), t_ntc1 + 1, outbuff, outbuff_size, nout);
513 nwords = (3 + nout) / 4; // round up to words
514 ddes[i].nwords = nwords;
515 ddes[i].offset = offset + ndata;
516 ndata += nwords;
517 ioRAW(file, outbuff, 4 * nwords, from_file);
518 }
519 }
520 delete[] outbuff;
521 }
522 // log section
523 ioRAW(file, &logsect, 1, from_file);
524 len_log = 2 + logsect.nlines;
525 for (i = 0; i < logsect.nlines; i++) {
526 len_log += (1 + (logsect.lines[i].len - 1) / 4);
527 }
528 if (!from_file) {
529 add.ad_log = add.ad_data + 33 + 2 * ndes + ndata;
530 add.ad_end = add.ad_log + len_log;
531 int curr_data_size = add.ad_log - add.ad_data;
532 int uncomp_data_size = 33 + t_nper * (t_nsp1 + 1) * (t_ntc1 + 1);
533 int curr_filesize = add.ad_end - 1;
534 int uncomp_filesize = add.ad_data - 1 + uncomp_data_size + len_log;
535 dhdr.d_crdata = static_cast<float>(uncomp_data_size) / static_cast<float>(curr_data_size);
536 dhdr.d_crfile = static_cast<float>(uncomp_filesize) / static_cast<float>(curr_filesize);
537 dhdr.d_exp_filesize = uncomp_filesize / 128; // in 512 byte blocks (vms default allocation unit)
538 int zero = fgetpos(file, &keep_pos);
539 if (!zero) {
540 logger.error() << "Error when getting file position: " << strerror(errno) << '\n';
541 return -1;
542 }
543
544 // update section addresses
545 zero = fsetpos(file, &add_pos);
546 if (!zero) {
547 logger.error() << "Error when setting file position: " << strerror(errno) << '\n';
548 return -1;
549 }
550
551 ioRAW(file, &add, 1, from_file);
552 // update data header and descriptors etc.
553 zero = fsetpos(file, &dhdr_pos);
554 if (!zero) {
555 logger.error() << "Error when setting file position to header: " << strerror(errno) << '\n';
556 return -1;
557 }
558
559 ioRAW(file, &dhdr, 1, from_file);
560 ioRAW(file, &ddes, ndes, from_file);
561 zero = fsetpos(file, &keep_pos);
562 if (!zero) {
563 logger.error() << "Error when restoring file position: " << strerror(errno) << '\n';
564 return -1;
565 }
566 }
567 return 0;
568}
569
571int ISISRAW::ioRAW(FILE *file, HDR_STRUCT *s, int len, bool from_file) {
572 ioRAW(file, reinterpret_cast<char *>(s), sizeof(HDR_STRUCT) * len, from_file);
573 return 0;
574}
575
577int ISISRAW::ioRAW(FILE *file, ADD_STRUCT *s, int len, bool from_file) {
578 ioRAW(file, reinterpret_cast<int *>(s), (sizeof(ADD_STRUCT) * len / sizeof(int)), from_file);
579 return 0;
580}
581
583int ISISRAW::ioRAW(FILE *file, USER_STRUCT *s, int len, bool from_file) {
584 ioRAW(file, reinterpret_cast<char *>(s), sizeof(USER_STRUCT) * len, from_file);
585 return 0;
586}
587
589int ISISRAW::ioRAW(FILE *file, RPB_STRUCT *s, int len, bool from_file) {
590 int i;
591 for (i = 0; i < len; i++) {
592 ioRAW(file, &(s[i].r_dur), 7, from_file);
593 ioRAW(file, &(s[i].r_gd_prtn_chrg), 2, from_file);
594 ioRAW(file, &(s[i].r_goodfrm), 7, from_file);
595 ioRAW(file, s[i].r_enddate, 20, from_file);
596 ioRAW(file, &(s[i].r_prop), 11, from_file);
597 }
598 return 0;
599}
600
602int ISISRAW::ioRAW(FILE *file, IVPB_STRUCT *s, int len, bool from_file) {
603 int i;
604 for (i = 0; i < len; i++) {
605 ioRAW(file, &(s[i].i_chfreq), 3, from_file);
606 ioRAW(file, &(s[i].delay_c1), 14, from_file);
607 ioRAW(file, &(s[i].i_xsect), 2, from_file);
608 ioRAW(file, &(s[i].i_posn), 3, from_file);
609 ioRAW(file, &(s[i].i_l1), 1, from_file);
610 ioRAW(file, &(s[i].i_rfreq), 1, from_file);
611 ioRAW(file, &(s[i].i_renergy), 2, from_file);
612 ioRAW(file, &(s[i].i_rslit), 2, from_file);
613 ioRAW(file, &(s[i].i_xcen), 2, from_file);
614 ioRAW(file, &(s[i].i_bestop), 1, from_file);
615 ioRAW(file, &(s[i].i_radbest), 4, from_file);
616 ioRAW(file, s[i].spare, 29, from_file);
617 }
618 return 0;
619}
620
622int ISISRAW::ioRAW(FILE *file, SPB_STRUCT *s, int len, bool from_file) {
623 int i;
624 for (i = 0; i < len; i++) {
625 ioRAW(file, &(s[i].e_posn), 3, from_file);
626 ioRAW(file, &(s[i].e_thick), 16, from_file);
627 ioRAW(file, s[i].e_name, 40, from_file);
628 ioRAW(file, &(s[i].e_equip), 35, from_file);
629 }
630 return 0;
631}
632
634int ISISRAW::ioRAW(FILE *file, SE_STRUCT *s, int len, bool from_file) {
635 int i;
636 for (i = 0; i < len; i++) {
637 ioRAW(file, s[i].sep_name, 8, from_file);
638 ioRAW(file, &(s[i].sep_value), 2, from_file);
639 ioRAW(file, s[i].sep_units, 8, from_file);
640 ioRAW(file, &(s[i].sep_low_trip), 7, from_file);
641 ioRAW(file, &(s[i].sep_stable), 2, from_file);
642 ioRAW(file, &(s[i].sep_cam_addr), 17, from_file);
643 }
644 return 0;
645}
646
648int ISISRAW::ioRAW(FILE *file, DAEP_STRUCT *s, int len, bool from_file) {
649 ioRAW(file, reinterpret_cast<int *>(s), sizeof(DAEP_STRUCT) * len / sizeof(int), from_file);
650 return 0;
651}
652
654int ISISRAW::ioRAW(FILE *file, DHDR_STRUCT *s, int len, bool from_file) {
655 int i;
656 for (i = 0; i < len; i++) {
657 ioRAW(file, &(s[i].d_comp), 3, from_file);
658 ioRAW(file, &(s[i].d_crdata), 2, from_file);
659 ioRAW(file, &(s[i].d_exp_filesize), 27, from_file);
660 }
661 return 0;
662}
663
665int ISISRAW::ioRAW(FILE *file, DDES_STRUCT *s, int len, bool from_file) {
666 int i;
667 for (i = 0; i < len; i++) {
668 ioRAW(file, &(s[i].nwords), 2, from_file);
669 }
670 return 0;
671}
672
674int ISISRAW::ioRAW(FILE *file, LOG_STRUCT *s, int len, bool from_file) {
675 int i;
676 for (i = 0; i < len; i++) {
677 ioRAW(file, &(s[i].ver), 2, from_file);
678 ioRAW(file, &(s[i].lines), s[i].nlines, from_file);
679 }
680 return 0;
681}
682
684int ISISRAW::ioRAW(FILE *file, LOG_LINE *s, int len, bool from_file) {
685 char padding[5];
686 memset(padding, ' ', sizeof(padding));
687 int i;
688 for (i = 0; i < len; i++) {
689 ioRAW(file, &(s[i].len), 1, from_file);
690 int nbytes_rounded = 4 * (1 + (s[i].len - 1) / 4);
691 ioRAW(file, &(s[i].data), s[i].len, from_file);
692 ioRAW(file, padding, nbytes_rounded - s[i].len, from_file);
693 }
694 return 0;
695}
696
698int ISISRAW::ioRAW(FILE *file, char *s, int len, bool from_file) {
699 if ((len <= 0) || (s == nullptr)) {
700 return 0;
701 }
702
703 if (from_file) {
704 size_t n = fread(s, sizeof(char), len, file);
705 return static_cast<int>(n - len);
706 } else {
707 fwrite(s, sizeof(char), len, file);
708 }
709
710 return 0;
711}
712
714int ISISRAW::ioRAW(FILE *file, int *s, int len, bool from_file) {
715 if ((len <= 0) || (s == nullptr)) {
716 return 0;
717 }
718
719 if (from_file) {
720 size_t n = fread(s, sizeof(int), len, file);
721 return static_cast<int>(n - len);
722 } else {
723 fwrite(s, sizeof(int), len, file);
724 }
725
726 return 0;
727}
728
730int ISISRAW::ioRAW(FILE *file, uint32_t *s, int len, bool from_file) {
731 if ((len <= 0) || (s == nullptr)) {
732 return 0;
733 }
734
735 if (from_file) {
736 size_t n = fread(s, sizeof(uint32_t), len, file);
737 return static_cast<int>(n - len);
738 } else {
739 fwrite(s, sizeof(uint32_t), len, file);
740 }
741 return 0;
742}
743
745int ISISRAW::ioRAW(FILE *file, float *s, int len, bool from_file) {
746 int errcode = 0;
747 if ((len <= 0) || (s == nullptr)) {
748 return 0;
749 }
750
751 if (from_file) {
752 size_t n = fread(s, sizeof(float), len, file);
753 vaxf_to_local(s, &len, &errcode);
754 return static_cast<int>(n - len);
755 } else {
756 local_to_vaxf(s, &len, &errcode);
757 fwrite(s, sizeof(float), len, file);
758 vaxf_to_local(s, &len, &errcode);
759 }
760 return 0;
761}
762
764int ISISRAW::ioRAW(FILE *file, char **s, int len, bool from_file) {
765 if (from_file) {
766 if (len > 0) {
767 delete[] *s;
768 *s = new char[len];
769 ioRAW(file, *s, len, from_file);
770 } else {
771 *s = nullptr;
772 }
773 } else {
774 if (*s != nullptr) {
775 ioRAW(file, *s, len, from_file);
776 }
777 }
778 return 0;
779}
780
782int ISISRAW::ioRAW(FILE *file, int **s, int len, bool from_file) {
783 if (from_file) {
784 if (len > 0) {
785 delete[] *s;
786 *s = new int[len];
787 ioRAW(file, *s, len, from_file);
788 } else {
789 *s = nullptr;
790 }
791 } else {
792 if (*s != nullptr) {
793 ioRAW(file, *s, len, from_file);
794 }
795 }
796 return 0;
797}
798
800int ISISRAW::ioRAW(FILE *file, uint32_t **s, int len, bool from_file) {
801 if (from_file) {
802 if (len > 0) {
803 delete[] *s;
804 *s = new uint32_t[len];
805 ioRAW(file, *s, len, from_file);
806 } else {
807 *s = nullptr;
808 }
809 } else {
810 if (*s != nullptr) {
811 ioRAW(file, *s, len, from_file);
812 }
813 }
814 return 0;
815}
816
818int ISISRAW::ioRAW(FILE *file, float **s, int len, bool from_file) {
819 if (from_file) {
820 if (len > 0) {
821 delete[] *s;
822 *s = new float[len];
823 ioRAW(file, *s, len, from_file);
824 } else {
825 *s = nullptr;
826 }
827 } else {
828 if (*s != nullptr) {
829 ioRAW(file, *s, len, from_file);
830 }
831 }
832 return 0;
833}
834
836int ISISRAW::ioRAW(FILE *file, SE_STRUCT **s, int len, bool from_file) {
837 if (from_file) {
838 if (len > 0) {
839 delete[] *s;
840 *s = new SE_STRUCT[len];
841 ioRAW(file, *s, len, from_file);
842 } else {
843 *s = nullptr;
844 }
845 } else {
846 if (*s != nullptr) {
847 ioRAW(file, *s, len, from_file);
848 }
849 }
850 return 0;
851}
852
854int ISISRAW::ioRAW(FILE *file, DDES_STRUCT **s, int len, bool from_file) {
855 if (from_file) {
856 if (len > 0) {
857 delete[] *s;
858 *s = new DDES_STRUCT[len];
859 ioRAW(file, *s, len, from_file);
860 } else {
861 *s = nullptr;
862 }
863 } else {
864 if (*s != nullptr) {
865 ioRAW(file, *s, len, from_file);
866 }
867 }
868 return 0;
869}
870
872int ISISRAW::ioRAW(FILE *file, LOG_LINE **s, int len, bool from_file) {
873 if (from_file) {
874 if (len > 0) {
875 delete[] *s;
876 *s = new LOG_LINE[len];
877 ioRAW(file, *s, len, from_file);
878 } else {
879 *s = nullptr;
880 }
881 } else {
882 if (*s != nullptr) {
883 ioRAW(file, *s, len, from_file);
884 }
885 }
886 return 0;
887}
888
890int ISISRAW::size_check() {
891 static int size_check_array[] = {sizeof(HDR_STRUCT), 80, sizeof(ADD_STRUCT), 9 * 4,
892 sizeof(USER_STRUCT), 8 * 20, sizeof(RPB_STRUCT), 32 * 4,
893 sizeof(IVPB_STRUCT), 64 * 4, sizeof(SPB_STRUCT), 64 * 4,
894 sizeof(SE_STRUCT), 32 * 4, sizeof(DAEP_STRUCT), 64 * 4,
895 sizeof(DHDR_STRUCT), 32 * 4, sizeof(DDES_STRUCT), 2 * 4};
896 for (unsigned i = 0; i < sizeof(size_check_array) / sizeof(int); i += 2) {
897 if (size_check_array[i] != size_check_array[i + 1]) {
898 logger.error() << "size check failed\n";
899 }
900 }
901 return 0;
902}
904int ISISRAW::vmstime(char *timbuf, int len, time_t time_value) {
905 /*
906 * get time in VMS format 01-JAN-1970 00:00:00
907 */
908 size_t i, n;
909#ifdef MS_VISUAL_STUDIO
910 struct tm tm_local;
911 errno_t err = localtime_s(&tm_local, &time_value);
912 if (err) {
913 return FAILURE;
914 }
915 const struct tm *tmstruct = &tm_local;
916#else //_WIN32
917 const struct tm *tmstruct = localtime(&time_value);
918#endif //_WIN32
919 n = strftime(timbuf, len, "%d-%b-%Y %H:%M:%S", tmstruct);
920 for (i = 0; i < n; i++) {
921 timbuf[i] = toupper(timbuf[i]);
922 }
923 return SUCCESS;
924}
925
927int ISISRAW::readFromFile(const char *filename, bool read_data) {
928#ifdef MS_VISUAL_STUDIO
929 FILE *input_file = NULL;
930 if (fopen_s(&input_file, filename, "rb") != 0) {
931 return -1;
932 }
933#else //_WIN32
934 FILE *input_file = fopen(filename, "rb");
935#endif //_WIN32
936 if (input_file != nullptr) {
937 ioRAW(input_file, true, read_data);
938 fclose(input_file);
939 return 0;
940 } else {
941 return -1;
942 }
943}
944
946int ISISRAW::printInfo(std::ostream &os) {
947 int i;
948 os << "INST section at " << add.ad_inst << " 0x" << std::hex << 4 * add.ad_inst << std::dec << '\n';
949 os << "SE section at " << add.ad_se << " 0x" << std::hex << 4 * add.ad_se << std::dec << '\n';
950 os << "Dae section at " << add.ad_dae << " 0x" << std::hex << 4 * add.ad_dae << std::dec << '\n';
951 os << "Tcb section at " << add.ad_tcb << " 0x" << std::hex << 4 * add.ad_tcb << std::dec << '\n';
952 os << "User section at " << add.ad_user << " 0x" << std::hex << 4 * add.ad_user << std::dec << '\n';
953 os << "Data section at " << add.ad_data << " 0x" << std::hex << 4 * add.ad_data << std::dec << '\n';
954 os << "Log section at " << add.ad_log << " 0x" << std::hex << 4 * add.ad_log << std::dec << '\n';
955 os << "End section at " << add.ad_end << " 0x" << std::hex << 4 * add.ad_end << std::dec << '\n';
956 os << "User data len " << u_len << '\n';
957 os << "Compression is " << (dhdr.d_comp == 0 ? "NONE" : "BYTE-RELATIVE") << '\n';
958 os << "Compression ratio of data = " << dhdr.d_crdata << '\n';
959 os << "Offsets of spectrum data\n";
960 for (i = 0; i < ((t_nsp1 + 1) * t_nper); i++) {
961 os << i << " " << ddes[i].nwords << " words at offset " << ddes[i].offset << '\n';
962 }
963 return 0;
964}
965
967ISISRAW::~ISISRAW() {
968 delete[] dat1;
969 delete[] ut;
970 delete[] mdet;
971 delete[] monp;
972 delete[] spec;
973 delete[] delt;
974 delete[] len2;
975 delete[] code;
976 delete[] tthe;
977 delete[] e_seblock;
978 delete[] crat;
979 delete[] modn;
980 delete[] mpos;
981 delete[] timr;
982 delete[] udet;
983 delete[] t_tcb1;
984 delete[] u_dat;
985 delete[] ddes;
986 for (int i = 0; i < logsect.nlines; i++) {
987 delete[] logsect.lines[i].data;
988 }
989 delete[] logsect.lines;
990}
991
993int ISISRAW::getTimeChannels(float *rtcb1, int n) {
994 if (n != t_ntc1 + 1) {
995 return -1;
996 }
997 float extra;
998 if (frmt_ver_no > 1) {
999 extra = float(4.0) * daep.a_delay; // add on frame sync delay
1000 } else {
1001 extra = 0.0; // old files did not have this
1002 }
1003 int i;
1004 for (i = 0; i < t_ntc1 + 1; i++) {
1005 rtcb1[i] = t_tcb1[i] * t_pre1 / float(32.0) + extra;
1006 }
1007 return 0;
1008}
byte_rel_expn
int byte_rel_expn(const char *data_in, int n_in, int n_from, int *data_out, int n_out)
Definition byte_rel_comp.cpp:119
FAILURE
#define FAILURE
Definition byte_rel_comp.cpp:26
SUCCESS
#define SUCCESS
Definition byte_rel_comp.cpp:27
byte_rel_comp
int byte_rel_comp(const int *data_in, int n_in, char *data_out, int max_out, int &n_out)
Definition byte_rel_comp.cpp:36
byte_rel_comp.h
ISISRAW::hdr
HDR_STRUCT hdr
header block (80 bytes)
Definition isisraw.h:277
ISISRAW::ut
float * ut
nuse UT* user tables (total size NUSE*NDET) ut01=phi
Definition isisraw.h:302
ISISRAW::logsect
LOG_STRUCT logsect
log section
Definition isisraw.h:342
ISISRAW::m_crpt
ISISCRPT_STRUCT * m_crpt
CRPT from ICP.
Definition isisraw.h:269
ISISRAW::t_tcm1
int t_tcm1[5]
time channel mode
Definition isisraw.h:326
ISISRAW::i_use
int i_use
number of user defined UTn tables NUSE
Definition isisraw.h:293
ISISRAW::spb
SPB_STRUCT spb
sample parameter block (64*4 bytes)
Definition isisraw.h:305
ISISRAW::delt
float * delt
hold off table (size NDET)
Definition isisraw.h:298
ISISRAW::modn
int * modn
module number for each detector (size NDET)
Definition isisraw.h:314
ISISRAW::t_tcp1
float t_tcp1[5][4]
time channel parameters
Definition isisraw.h:327
ISISRAW::e_nse
int e_nse
number of controlled SEPs NSEP
Definition isisraw.h:306
ISISRAW::getTimeChannels
int getTimeChannels(float *rtcb1, int n)
rtcb1 is of size t_ntc1+1
Definition isisraw.cpp:993
ISISRAW::i_inst
char i_inst[8]
instrument name
Definition isisraw.h:289
ISISRAW::dat1
uint32_t * dat1
compressed data for (NTC1+1)*(NSP1+1)*NPER values
Definition isisraw.h:341
ISISRAW::ver2
int ver2
run section version number VER2 (=1)
Definition isisraw.h:282
ISISRAW::ISISRAW
ISISRAW()
stuff
Definition isisraw.cpp:23
ISISRAW::t_ntrg
int t_ntrg
number of time regimes (=1)
Definition isisraw.h:320
ISISRAW::i_det
int i_det
number of detectors NDET
Definition isisraw.h:291
ISISRAW::daep
DAEP_STRUCT daep
DAE parameter block (size 64*4 bytes)
Definition isisraw.h:311
ISISRAW::ddes
DDES_STRUCT * ddes
(NSP1+1)*NPER items, totoal size (NSP1+1)*NPER*2*4 bytes
Definition isisraw.h:340
ISISRAW::code
int * code
code for UTn tables (size NDET)
Definition isisraw.h:300
ISISRAW::t_nper
int t_nper
number of periods
Definition isisraw.h:322
ISISRAW::dhdr
DHDR_STRUCT dhdr
size 32*4 bytes
Definition isisraw.h:337
ISISRAW::printInfo
int printInfo(std::ostream &os)
stuff
Definition isisraw.cpp:946
ISISRAW::t_tcb1
int * t_tcb1
time channel boundaries in clock pulses (size NTC1+1)
Definition isisraw.h:329
ISISRAW::t_nsp1
int t_nsp1
number of spectra in time regime 1
Definition isisraw.h:324
ISISRAW::mdet
int * mdet
detector number for monitors (size NMON)
Definition isisraw.h:295
ISISRAW::ver3
int ver3
instrument section version number (=2)
Definition isisraw.h:288
ISISRAW::vmstime
static int vmstime(char *timbuf, int len, time_t time_value)
stuff
Definition isisraw.cpp:904
ISISRAW::m_char_items
item_struct< char > m_char_items
dunno
Definition isisraw.h:270
ISISRAW::readFromFile
int readFromFile(const char *filename, bool read_data=true)
stuff
Definition isisraw.cpp:927
ISISRAW::m_real_items
item_struct< float > m_real_items
dunno
Definition isisraw.h:271
ISISRAW::ver5
int ver5
DAE section version number (=2)
Definition isisraw.h:310
ISISRAW::ver7
int ver7
user version number (=1)
Definition isisraw.h:332
ISISRAW::timr
int * timr
time regime for each detector (size NDET)
Definition isisraw.h:316
ISISRAW::user
USER_STRUCT user
user information (8*20 bytes)
Definition isisraw.h:285
ISISRAW::addItems
int addItems()
stuff
Definition isisraw.cpp:131
ISISRAW::updateFromCRPT
int updateFromCRPT()
stuff
Definition isisraw.cpp:189
ISISRAW::i_mon
int i_mon
number of monitors NMON
Definition isisraw.h:292
ISISRAW::crat
int * crat
crate number for each detector (size NDET)
Definition isisraw.h:313
ISISRAW::size_check
int size_check()
stuff
Definition isisraw.cpp:890
ISISRAW::ioRAW
virtual int ioRAW(FILE *file, bool from_file, bool read_data=true)
stuff
Definition isisraw.cpp:401
ISISRAW::ver4
int ver4
SE section version number (=2)
Definition isisraw.h:304
ISISRAW::ver8
int ver8
data version number (=2)
Definition isisraw.h:336
ISISRAW::u_dat
float * u_dat
user defined data (ULEN, max size 400 words)
Definition isisraw.h:334
ISISRAW::data_format
int data_format
data section format (0 = by TC, 1 = by spectrum)
Definition isisraw.h:280
ISISRAW::r_title
char r_title[80]
run title
Definition isisraw.h:284
ISISRAW::r_number
int r_number
run number
Definition isisraw.h:283
ISISRAW::mpos
int * mpos
module position for each detector (size NDET)
Definition isisraw.h:315
ISISRAW::t_nfpp
int t_nfpp
number of frames per period
Definition isisraw.h:321
ISISRAW::ver6
int ver6
TCB section version number (=1)
Definition isisraw.h:319
ISISRAW::ivpb
IVPB_STRUCT ivpb
instrument parameter block (64*4 bytes)
Definition isisraw.h:290
ISISRAW::udet
int * udet
user detector number for each detector (size NDET)
Definition isisraw.h:317
ISISRAW::monp
int * monp
prescale value for each monitor (size NMON)
Definition isisraw.h:296
ISISRAW::u_len
int u_len
length of user data section
Definition isisraw.h:333
ISISRAW::rpb
RPB_STRUCT rpb
run parameter block (32*4 bytes)
Definition isisraw.h:286
ISISRAW::spec
int * spec
spectrum number table (size NDET)
Definition isisraw.h:297
ISISRAW::e_seblock
SE_STRUCT * e_seblock
NSEP SE parameter blocks (total size NSEP*32*4 bytes)
Definition isisraw.h:308
ISISRAW::add
struct ADD_STRUCT add
9*4 bytes
Definition isisraw.h:279
ISISRAW::~ISISRAW
virtual ~ISISRAW()
stuff
Definition isisraw.cpp:967
ISISRAW::t_ntc1
int t_ntc1
number of time channels in time regime 1
Definition isisraw.h:325
ISISRAW::tthe
float * tthe
2theta scattering angle (size NDET)
Definition isisraw.h:301
ISISRAW::len2
float * len2
L2 table (size NDET)
Definition isisraw.h:299
ISISRAW::m_int_items
item_struct< int > m_int_items
dunno
Definition isisraw.h:272
ISISRAW::t_pre1
int t_pre1
prescale for 32MHz clock
Definition isisraw.h:328
ISISRAW::t_pmap
int t_pmap[256]
period number for each basic period
Definition isisraw.h:323
ISISRAW::frmt_ver_no
int frmt_ver_no
format version number VER1 (=2)
Definition isisraw.h:278
Mantid::Kernel::Logger
The Logger class is in charge of the publishing messages from the framework through various channels.
Definition Logger.h:51
item_struct::addItem
int addItem(const std::string &name, const T *value, bool det_average=false, const int *dim0=nullptr, const int *dim1=nullptr)
Adds an item.
Definition item_struct.h:43
isisraw.h
ISIS VMS raw file definitions.
ADD_STRUCT
address offsets to various sections (9*4 bytes)
Definition isisraw.h:35
ADD_STRUCT::ad_dae
int ad_dae
ad_se + 66 + nse*32
Definition isisraw.h:39
ADD_STRUCT::ad_user
int ad_user
ad_tcb + 288 + (ntc1 + 1)
Definition isisraw.h:41
ADD_STRUCT::ad_data
int ad_data
ad_user + 2 + ulen
Definition isisraw.h:42
ADD_STRUCT::ad_tcb
int ad_tcb
ad_dae + 65 + 5*ndet
Definition isisraw.h:40
ADD_STRUCT::ad_run
int ad_run
32 (1+offset_of(ver2))
Definition isisraw.h:36
ADD_STRUCT::ad_end
int ad_end
1+end of file
Definition isisraw.h:44
ADD_STRUCT::ad_inst
int ad_inst
ad_run + 94
Definition isisraw.h:37
ADD_STRUCT::ad_log
int ad_log
ad_data + 33 +
Definition isisraw.h:43
ADD_STRUCT::ad_se
int ad_se
ad_inst + 70 + 2*nmon+(5+nuse)*ndet
Definition isisraw.h:38
DAEP_STRUCT
DAE parameters block (64*4 bytes)
Definition isisraw.h:185
DAEP_STRUCT::mon1_module
int mon1_module
module for MON 1 ( 4 bits) ***B
Definition isisraw.h:200
DAEP_STRUCT::a_pars
int a_pars
Word length in bulk store memory.
Definition isisraw.h:186
DAEP_STRUCT::mon1_mask
int mon1_mask
mask for MON 1 (c4:m4:d12) ***B
Definition isisraw.h:202
DAEP_STRUCT::tr_shift
int tr_shift[3]
set to shift value (us) of each TR if (using_tr_shift >
Definition isisraw.h:216
DAEP_STRUCT::ppp_raw_low
int ppp_raw_low
raw PPP total (low 32 bits) ***B
Definition isisraw.h:192
DAEP_STRUCT::ext_vetos
int ext_vetos[3]
External vetoes 0,1,2 (0 dis,1.
Definition isisraw.h:212
DAEP_STRUCT::a_delay
int a_delay
frame synch delay (4�s steps) ***B
Definition isisraw.h:209
DAEP_STRUCT::mon2_crate
int mon2_crate
crate for MON 2 ( 4 bits) ***B
Definition isisraw.h:205
DAEP_STRUCT::ppp_good_high
int ppp_good_high
good PPP total (high 32 bits) ***B
Definition isisraw.h:189
DAEP_STRUCT::mon1_crate
int mon1_crate
crate for MON 1 ( 4 bits) ***B
Definition isisraw.h:201
DAEP_STRUCT::ppp_good_low
int ppp_good_low
good PPP total (low 32 bits) ***B
Definition isisraw.h:190
DAEP_STRUCT::a_sync
int a_sync
frm snch origin(0:none/1:ext/2:int)***B
Definition isisraw.h:210
DAEP_STRUCT::mem_size
int mem_size
Length of bulk store memory (bytes)**A.
Definition isisraw.h:187
DAEP_STRUCT::ppp_raw_high
int ppp_raw_high
raw PPP total (high 32 bits) ***B
Definition isisraw.h:191
DAEP_STRUCT::mon2_mask
int mon2_mask
mask for MON 2 (c4:m4:d12) ***B
Definition isisraw.h:206
DAEP_STRUCT::n_tr_shift
int n_tr_shift
en)
Definition isisraw.h:215
DAEP_STRUCT::mon2_detector
int mon2_detector
detector for MON 2 (12 bits) ***B
Definition isisraw.h:203
DAEP_STRUCT::mon2_module
int mon2_module
module for MON 2 ( 4 bits) ***B
Definition isisraw.h:204
DAEP_STRUCT::a_smp
int a_smp
Secondary Master Pulse (0:en,1:dis)
Definition isisraw.h:211
DAEP_STRUCT::mon1_detector
int mon1_detector
detector for MON 1 (12 bits) ***B
Definition isisraw.h:199
DDES_STRUCT
2*4 bytes
Definition isisraw.h:241
DDES_STRUCT::nwords
int nwords
number of compressed words in spectrum
Definition isisraw.h:242
DDES_STRUCT::offset
int offset
offset to compressed spectrum
Definition isisraw.h:243
DHDR_STRUCT
data section header (32*4 bytes)
Definition isisraw.h:224
DHDR_STRUCT::d_comp
int d_comp
compression type (0=none, 1 = byte relative)
Definition isisraw.h:225
DHDR_STRUCT::d_crfile
float d_crfile
compression ratio for whole file
Definition isisraw.h:229
DHDR_STRUCT::d_crdata
float d_crdata
compression ratio for data
Definition isisraw.h:228
DHDR_STRUCT::d_exp_filesize
int d_exp_filesize
equivalent version 1 filesize
Definition isisraw.h:230
HDR_STRUCT
Run header (80 bytes)
Definition isisraw.h:22
HDR_STRUCT::hd_date
char hd_date[12]
start date
Definition isisraw.h:27
HDR_STRUCT::hd_time
char hd_time[8]
start time
Definition isisraw.h:28
HDR_STRUCT::inst_abrv
char inst_abrv[3]
instrument abbreviated name
Definition isisraw.h:23
HDR_STRUCT::hd_dur
char hd_dur[8]
run duration (uA.hour) constructor
Definition isisraw.h:29
HDR_STRUCT::hd_run
char hd_run[5]
run number
Definition isisraw.h:24
HDR_STRUCT::hd_user
char hd_user[20]
user name
Definition isisraw.h:25
HDR_STRUCT::hd_title
char hd_title[24]
short title
Definition isisraw.h:26
IVPB_STRUCT
instrument parameter block (64*4 bytes)
Definition isisraw.h:89
IVPB_STRUCT::i_ycen
float i_ycen
LOQ y centre.
Definition isisraw.h:119
IVPB_STRUCT::i_xsect
float i_xsect
beam aperture horizontal (mm)
Definition isisraw.h:107
IVPB_STRUCT::i_chopsiz
float i_chopsiz
dunno
Definition isisraw.h:99
IVPB_STRUCT::i_aofi
float i_aofi
angle of incidence (CRISP)
Definition isisraw.h:124
IVPB_STRUCT::i_sddist
float i_sddist
source to detector distance (LOQ)
Definition isisraw.h:122
IVPB_STRUCT::i_l1
float i_l1
L1 scattering length.
Definition isisraw.h:112
IVPB_STRUCT::i_xcen
float i_xcen
LOQ x centre.
Definition isisraw.h:118
IVPB_STRUCT::i_ysect
float i_ysect
beam aperture vertical (mm)
Definition isisraw.h:108
IVPB_STRUCT::i_bestop
int i_bestop
beam_stop LOQ
Definition isisraw.h:120
IVPB_STRUCT::i_foeang
float i_foeang
foe angle LOQ
Definition isisraw.h:123
LOG_LINE
log line entry
Definition isisraw.h:249
LOG_LINE::len
int len
real length of data
Definition isisraw.h:250
LOG_LINE::data
char * data
padded to multiple of 4 bytes
Definition isisraw.h:251
LOG_STRUCT
log line entry
Definition isisraw.h:257
LOG_STRUCT::lines
LOG_LINE * lines
size nlines
Definition isisraw.h:260
LOG_STRUCT::nlines
int nlines
number of lines
Definition isisraw.h:259
RPB_STRUCT
Run parameter block (32*4 bytes)
Definition isisraw.h:62
RPB_STRUCT::r_dur_secs
int r_dur_secs
actual run duration in seconds
Definition isisraw.h:75
RPB_STRUCT::r_freq
int r_freq
2**k where source frequency = 50 / 2**k
Definition isisraw.h:69
RPB_STRUCT::r_mon_sum2
int r_mon_sum2
monitor sum 2
Definition isisraw.h:77
RPB_STRUCT::r_endtime
char r_endtime[8]
format HH-MM-SS
Definition isisraw.h:80
RPB_STRUCT::r_enddate
char r_enddate[12]
format DD-MMM-YYYY
Definition isisraw.h:79
RPB_STRUCT::r_goodfrm
int r_goodfrm
good frames
Definition isisraw.h:72
RPB_STRUCT::r_rawfrm
int r_rawfrm
raw frames
Definition isisraw.h:73
RPB_STRUCT::r_gd_prtn_chrg
float r_gd_prtn_chrg
good proton charge (uA.hour)
Definition isisraw.h:70
RPB_STRUCT::r_durunits
int r_durunits
scaler for above (1=seconds)
Definition isisraw.h:64
RPB_STRUCT::r_mon_sum1
int r_mon_sum1
monitor sum 1
Definition isisraw.h:76
RPB_STRUCT::r_mon_sum3
int r_mon_sum3
monitor sum 3
Definition isisraw.h:78
RPB_STRUCT::r_dur
int r_dur
actual run duration
Definition isisraw.h:63
RPB_STRUCT::r_prop
int r_prop
RB (proposal) number.
Definition isisraw.h:81
RPB_STRUCT::r_tot_prtn_chrg
float r_tot_prtn_chrg
total proton charge (uA.hour)
Definition isisraw.h:71
SE_STRUCT
sample environment block (32*4 bytes)
Definition isisraw.h:160
SPB_STRUCT
sample parameter block (64*4 bytes)
Definition isisraw.h:131
SPB_STRUCT::e_type
int e_type
sample type (1=sample+can,2=empty can)
Definition isisraw.h:133
SPB_STRUCT::e_width
float e_width
sample width (mm)
Definition isisraw.h:137
SPB_STRUCT::e_phi
float e_phi
phi sample angle (degrees)
Definition isisraw.h:140
SPB_STRUCT::e_geom
int e_geom
sample geometry
Definition isisraw.h:134
SPB_STRUCT::e_height
float e_height
sample height (mm)
Definition isisraw.h:136
SPB_STRUCT::e_thick
float e_thick
sample thickness normal to sample (mm)
Definition isisraw.h:135
USER_STRUCT
user information (8*20 bytes)
Definition isisraw.h:50
USER_STRUCT::r_instit
char r_instit[20]
institute
Definition isisraw.h:55
USER_STRUCT::r_user
char r_user[20]
name
Definition isisraw.h:51
vaxf_to_local
void vaxf_to_local(float *val, const int *n, int *errcode)
Definition vms_convert.cpp:353
local_to_vaxf
void local_to_vaxf(float *val, const int *n, int *errcode)
Definition vms_convert.cpp:380
vms_convert.h
Generated by doxygen 1.9.8