musrfit 1.10.0
mud_gen.c
Go to the documentation of this file.
1/*
2 * mud_gen.c -- procedures for MUD_FMT_GEN sections
3 *
4 * Copyright (C) 1994-2010 TRIUMF (Vancouver, Canada)
5 *
6 * Authors: T. Whidden, D. Arseneau
7 *
8 * Released under the GNU LGPL - see http://www.gnu.org/licenses
9 *
10 * This program is free software; you can distribute it and/or modify it under
11 * the terms of the Lesser GNU General Public License as published by the Free
12 * Software Foundation; either version 2 of the License, or any later version.
13 * Accordingly, this program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15 * or FITNESS FOR A PARTICULAR PURPOSE. See the Lesser GNU General Public License
16 * for more details.
17 *
18 * Revision history:
19 * v1.0 26-Jan-1994 [T. Whidden] Initial version
20 * v1.0a 15-Feb-1994 [T. Whidden] Split ...GEN_HIST to ...GEN_HIST_HDR
21 * and ...GEN_HIST_DAT
22 * v1.0b 14-Apr-1994 [T. Whidden] operator -> experimenter
23 * v1.0c 17-Apr-1994 [T. Whidden] added temperature and field to RUN_DESC
24 * v1.0d 11-Jul-1994 [TW] Fixed "unaligned data access" messages in
25 * MUD_SEC_GEN_HIST_pack()
26 * 25-Nov-2009 DA Handle 8-byte time_t
27 */
28
29#include <time.h>
30#include <math.h>
31#include "mud.h"
32
33/* #define DEBUG 1 */ /* (un)comment for debug */
34#define PACK_OP 1
35#define UNPACK_OP 2
36static int pack_op;
37
38static int MUD_SEC_GEN_HIST_dopack _ANSI_ARGS_(( int num, int inBinSize, void* inHist, int outBinSize, void* outHist ));
39static int n_bytes_needed _ANSI_ARGS_(( UINT32 val ));
40static UINT32 varBinArray _ANSI_ARGS_(( void* pHistData, int binSize, int index ));
41static void next_few_bins _ANSI_ARGS_(( int num_tot, int inBinSize, void* pHistData, int outBinSize_now, MUD_VAR_BIN_LEN_TYPE *pNum_next, MUD_VAR_BIN_SIZ_TYPE *pOutBinSize_next ));
42
43
44int
45MUD_SEC_GEN_RUN_DESC_proc( MUD_OPT op, BUF* pBuf, MUD_SEC_GEN_RUN_DESC* pMUD )
46{
47 int size;
48 char tempStr1[32];
49 char tempStr2[32];
50 time_t bintime;
51
52 switch( op )
53 {
54 case MUD_FREE:
55 _free( pMUD->title );
56 _free( pMUD->lab );
57 _free( pMUD->area );
58 _free( pMUD->method );
59 _free( pMUD->apparatus );
60 _free( pMUD->insert );
61 _free( pMUD->sample );
62 _free( pMUD->orient );
63 _free( pMUD->das );
64 _free( pMUD->experimenter );
65 _free( pMUD->temperature );
66 _free( pMUD->field );
67 break;
68 case MUD_DECODE:
69 decode_4( pBuf, &pMUD->exptNumber );
70 decode_4( pBuf, &pMUD->runNumber );
71 decode_4( pBuf, &pMUD->timeBegin );
72 decode_4( pBuf, &pMUD->timeEnd );
73 decode_4( pBuf, &pMUD->elapsedSec );
74 decode_str( pBuf, &pMUD->title );
75 decode_str( pBuf, &pMUD->lab );
76 decode_str( pBuf, &pMUD->area );
77 decode_str( pBuf, &pMUD->method );
78 decode_str( pBuf, &pMUD->apparatus );
79 decode_str( pBuf, &pMUD->insert );
80 decode_str( pBuf, &pMUD->sample );
81 decode_str( pBuf, &pMUD->orient );
82 decode_str( pBuf, &pMUD->das );
83 decode_str( pBuf, &pMUD->experimenter );
84 decode_str( pBuf, &pMUD->temperature );
85 decode_str( pBuf, &pMUD->field );
86 break;
87 case MUD_ENCODE:
88 encode_4( pBuf, &pMUD->exptNumber );
89 encode_4( pBuf, &pMUD->runNumber );
90 encode_4( pBuf, &pMUD->timeBegin );
91 encode_4( pBuf, &pMUD->timeEnd );
92 encode_4( pBuf, &pMUD->elapsedSec );
93 encode_str( pBuf, &pMUD->title );
94 encode_str( pBuf, &pMUD->lab );
95 encode_str( pBuf, &pMUD->area );
96 encode_str( pBuf, &pMUD->method );
97 encode_str( pBuf, &pMUD->apparatus );
98 encode_str( pBuf, &pMUD->insert );
99 encode_str( pBuf, &pMUD->sample );
100 encode_str( pBuf, &pMUD->orient );
101 encode_str( pBuf, &pMUD->das );
102 encode_str( pBuf, &pMUD->experimenter );
103 encode_str( pBuf, &pMUD->temperature );
104 encode_str( pBuf, &pMUD->field );
105 break;
106 case MUD_GET_SIZE:
107 size = 3*sizeof( UINT32 ) + 2*sizeof( TIME );
108 size += sizeof( MUD_STR_LEN_TYPE ) + _strlen( pMUD->title );
109 size += sizeof( MUD_STR_LEN_TYPE ) + _strlen( pMUD->lab );
110 size += sizeof( MUD_STR_LEN_TYPE ) + _strlen( pMUD->area );
111 size += sizeof( MUD_STR_LEN_TYPE ) + _strlen( pMUD->method );
112 size += sizeof( MUD_STR_LEN_TYPE ) + _strlen( pMUD->apparatus );
113 size += sizeof( MUD_STR_LEN_TYPE ) + _strlen( pMUD->insert );
114 size += sizeof( MUD_STR_LEN_TYPE ) + _strlen( pMUD->sample );
115 size += sizeof( MUD_STR_LEN_TYPE ) + _strlen( pMUD->orient );
116 size += sizeof( MUD_STR_LEN_TYPE ) + _strlen( pMUD->das );
117 size += sizeof( MUD_STR_LEN_TYPE ) + _strlen( pMUD->experimenter );
118 size += sizeof( MUD_STR_LEN_TYPE ) + _strlen( pMUD->temperature );
119 size += sizeof( MUD_STR_LEN_TYPE ) + _strlen( pMUD->field );
120 return( size );
121 case MUD_SHOW:
122 printf( " MUD_SEC_GEN_RUN_DESC: expt:[%ld], run:[%ld]\n",
123 (long)(pMUD->exptNumber), (long)(pMUD->runNumber) );
124 bintime = pMUD->timeBegin;
125 strncpy( tempStr1, ctime( &bintime ), sizeof(tempStr1) );
126 tempStr1[strlen(tempStr1)-1] = '\0';
127 bintime = pMUD->timeEnd;
128 strncpy( tempStr2, ctime( &bintime ), sizeof(tempStr2) );
129 tempStr2[strlen(tempStr2)-1] = '\0';
130 printf( " timeBegin:[%s] [%lu]\n", tempStr1, (unsigned long)(pMUD->timeBegin) );
131 printf( " timeEnd:[%s] [%lu]\n", tempStr2, (unsigned long)(pMUD->timeEnd) );
132 printf( " elapsedSec:[%ld]\n", (long)(pMUD->elapsedSec) );
133 if( pMUD->title ) printf( " title:\"%s\"\n", pMUD->title );
134 if( pMUD->lab ) printf( " lab:\"%s\"\n", pMUD->lab );
135 if( pMUD->area ) printf( " area:\"%s\"\n", pMUD->area );
136 if( pMUD->method ) printf( " method:\"%s\"\n", pMUD->method );
137 if( pMUD->apparatus )
138 printf( " apparatus:\"%s\"\n", pMUD->apparatus );
139 if( pMUD->insert ) printf( " insert:\"%s\"\n", pMUD->insert );
140 if( pMUD->sample ) printf( " sample:\"%s\"\n", pMUD->sample );
141 if( pMUD->orient ) printf( " orient:\"%s\"\n", pMUD->orient );
142 if( pMUD->das ) printf( " das:\"%s\"\n", pMUD->das );
143 if( pMUD->experimenter )
144 printf( " experimenter:\"%s\"\n", pMUD->experimenter );
145 if( pMUD->temperature )
146 printf( " temperature:\"%s\"\n", pMUD->temperature );
147 if( pMUD->field )
148 printf( " field:\"%s\"\n", pMUD->field );
149 break;
150 case MUD_HEADS:
151 printf( "Run number: %ld\n", (long)(pMUD->runNumber) );
152 printf( " exper num: %ld\n", (long)(pMUD->exptNumber) );
153 if( pMUD->experimenter )
154 printf( " operator: %s\n", pMUD->experimenter );
155 if( pMUD->method ) printf( " method: %s\n", pMUD->method );
156 bintime = pMUD->timeBegin;
157 strncpy( tempStr1, ctime( &bintime ), sizeof(tempStr1) );
158 tempStr1[strlen(tempStr1)-1] = '\0';
159 bintime = pMUD->timeEnd;
160 strncpy( tempStr2, ctime( &bintime ), sizeof(tempStr2) );
161 tempStr2[strlen(tempStr2)-1] = '\0';
162 printf( " began: %s\n ended: %s\n",
163 tempStr1, tempStr2 );
164 printf( " elapsed: %ld:%.2d:%.2d (%lu seconds)\n",
165 (long)(pMUD->elapsedSec/3600), ((pMUD->elapsedSec%3600)/60), (pMUD->elapsedSec%60),
166 (unsigned long)(pMUD->elapsedSec) );
167 if( pMUD->title )
168 {
169 if( strlen( pMUD->title ) > 63 && strlen( pMUD->title ) < 80 )
170 {
171 printf( " title:\n%s\n", pMUD->title );
172 }
173 else
174 {
175 printf( " title: %s\n", pMUD->title );
176 }
177 }
178 if( pMUD->sample ) printf( " sample: %s\n", pMUD->sample );
179 if( pMUD->orient ) printf( " orient: %s\n", pMUD->orient );
180 if( pMUD->temperature )
181 printf( " temperature: %s\n", pMUD->temperature );
182 if( pMUD->field ) printf( " field: %s\n", pMUD->field );
183 if( pMUD->lab ) printf( " lab: %s\n", pMUD->lab );
184 if( pMUD->area ) printf( " area: %s\n", pMUD->area );
185 if( pMUD->das ) printf( " das: %s\n", pMUD->das );
186 if( pMUD->apparatus )
187 printf( " apparatus: %s\n", pMUD->apparatus );
188 if( pMUD->insert ) printf( " insert: %s\n", pMUD->insert );
189 break;
190 }
191 return( 1 );
192}
193
194
195int
196MUD_SEC_GEN_HIST_HDR_proc( MUD_OPT op, BUF* pBuf, MUD_SEC_GEN_HIST_HDR* pMUD )
197{
198 int size;
199 UINT32 fsBin;
200 double nsBin;
201
202 switch( op )
203 {
204 case MUD_FREE:
205 _free( pMUD->title );
206 break;
207 case MUD_DECODE:
208 decode_4( pBuf, &pMUD->histType );
209 decode_4( pBuf, &pMUD->nBytes );
210 decode_4( pBuf, &pMUD->nBins );
211 decode_4( pBuf, &pMUD->bytesPerBin );
212 decode_4( pBuf, &pMUD->fsPerBin );
213 decode_4( pBuf, &pMUD->t0_ps );
214 decode_4( pBuf, &pMUD->t0_bin );
215 decode_4( pBuf, &pMUD->goodBin1 );
216 decode_4( pBuf, &pMUD->goodBin2 );
217 decode_4( pBuf, &pMUD->bkgd1 );
218 decode_4( pBuf, &pMUD->bkgd2 );
219 decode_4( pBuf, &pMUD->nEvents );
220 decode_str( pBuf, &pMUD->title );
221 break;
222 case MUD_ENCODE:
223 encode_4( pBuf, &pMUD->histType );
224 encode_4( pBuf, &pMUD->nBytes );
225 encode_4( pBuf, &pMUD->nBins );
226 encode_4( pBuf, &pMUD->bytesPerBin );
227 encode_4( pBuf, &pMUD->fsPerBin );
228 encode_4( pBuf, &pMUD->t0_ps );
229 encode_4( pBuf, &pMUD->t0_bin );
230 encode_4( pBuf, &pMUD->goodBin1 );
231 encode_4( pBuf, &pMUD->goodBin2 );
232 encode_4( pBuf, &pMUD->bkgd1 );
233 encode_4( pBuf, &pMUD->bkgd2 );
234 encode_4( pBuf, &pMUD->nEvents );
235 encode_str( pBuf, &pMUD->title );
236 break;
237 case MUD_GET_SIZE:
238 size = 12*sizeof( UINT32 );
239 size += sizeof( MUD_STR_LEN_TYPE ) + _strlen( pMUD->title );
240 return( size );
241 case MUD_SHOW:
242 printf( " MUD_SEC_GEN_HIST_HDR: histType:[0x%08lX]\n", (unsigned long)(pMUD->histType) );
243 printf( " nBytes:[%ld], nBins:[%ld], nEvents:[%lu]\n",
244 (long)(pMUD->nBytes), (long)(pMUD->nBins), (unsigned long)(pMUD->nEvents) );
245 printf( " bytesPerBin:[%ld], fsPerBin:[%ld], t0_ps:[%ld], t0_bin:[%ld]\n",
246 (long)(pMUD->bytesPerBin), (long)(pMUD->fsPerBin), (long)(pMUD->t0_ps), (long)(pMUD->t0_bin) );
247 printf( " goodBin1:[%ld], goodBin2:[%ld], bkgd1:[%ld], bkgd2:[%ld]\n",
248 (long)(pMUD->goodBin1), (long)(pMUD->goodBin2), (long)(pMUD->bkgd1), (long)(pMUD->bkgd2) );
249 if( pMUD->title ) printf( " title:\"%s\"\n", pMUD->title );
250 break;
251 case MUD_HEADS:
252 if( pMUD->title ) printf( "Hist title: %s\n", pMUD->title );
253 printf( " nBins: %ld, nEvents: %lu, ",
254 (long)(pMUD->nBins), (unsigned long)(pMUD->nEvents) );
255 fsBin = pMUD->fsPerBin;
256 if( fsBin < 16 )
257 {
258 nsBin = 0.078125 * pow( (double)2.0, (double)fsBin );
259 printf( "ns_per_Bin: %.6lf\n", nsBin );
260 }
261 else if( fsBin < 29 )
262 {
263 nsBin = 0.048828125 * pow( (double)2.0, (double)(fsBin - 16) );
264 printf( "ns_per_Bin: %.9lf\n", nsBin );
265 }
266 else
267 {
268 nsBin = (double)fsBin * 0.000001;
269 printf( "ns_per_Bin: %lf\n", nsBin );
270 }
271
272 printf( " t0_ps: %ld, t0_bin: %ld\n",
273 (long)(pMUD->t0_ps), (long)(pMUD->t0_bin) );
274 printf( " goodBin1: %ld, goodBin2: %ld, bkgd1: %ld, bkgd2: %ld\n",
275 (long)(pMUD->goodBin1), (long)(pMUD->goodBin2), (long)(pMUD->bkgd1), (long)(pMUD->bkgd2) );
276 break;
277 }
278 return( 1 );
279}
280
281
282int
283MUD_SEC_GEN_HIST_DAT_proc( MUD_OPT op, BUF* pBuf, MUD_SEC_GEN_HIST_DAT* pMUD )
284{
285 int size;
286
287 switch( op )
288 {
289 case MUD_FREE:
290 _free( pMUD->pData );
291 break;
292 case MUD_DECODE:
293 decode_4( pBuf, &pMUD->nBytes );
294 pMUD->pData = (char*)zalloc( pMUD->nBytes );
295 _decode_obj( pBuf, pMUD->pData, pMUD->nBytes );
296 break;
297 case MUD_ENCODE:
298 encode_4( pBuf, &pMUD->nBytes );
299 _encode_obj( pBuf, pMUD->pData, pMUD->nBytes );
300 break;
301 case MUD_GET_SIZE:
302 size = sizeof( UINT32 );
303 size += pMUD->nBytes;
304 return( size );
305 case MUD_SHOW:
306 printf( " MUD_SEC_GEN_HIST_DAT: nBytes:[%ld]\n", (long)(pMUD->nBytes) );
307 break;
308 case MUD_HEADS:
309 break;
310 }
311 return( 1 );
312}
313
314
315int
316MUD_SEC_GEN_SCALER_proc( MUD_OPT op, BUF* pBuf, MUD_SEC_GEN_SCALER* pMUD )
317{
318 int size;
319
320 switch( op )
321 {
322 case MUD_FREE:
323 _free( pMUD->label );
324 break;
325 case MUD_DECODE:
326 decode_4( pBuf, &pMUD->counts[0] );
327 decode_4( pBuf, &pMUD->counts[1] );
328 decode_str( pBuf, &pMUD->label );
329 break;
330 case MUD_ENCODE:
331 encode_4( pBuf, &pMUD->counts[0] );
332 encode_4( pBuf, &pMUD->counts[1] );
333 encode_str( pBuf, &pMUD->label );
334 break;
335 case MUD_GET_SIZE:
336 size = 2*sizeof( UINT32 );
337 size += sizeof( MUD_STR_LEN_TYPE ) + _strlen( pMUD->label );
338 return( size );
339 case MUD_SHOW:
340 printf( " MUD_SEC_GEN_SCALER: counts[1]:[%lu], counts[0]:[%lu]\n",
341 (unsigned long)(pMUD->counts[1]), (unsigned long)(pMUD->counts[0]) );
342 if( pMUD->label ) printf( " label:\"%s\"\n", pMUD->label );
343 break;
344 case MUD_HEADS:
345 printf( " Scaler " );
346 if( pMUD->label ) printf( "%8s", pMUD->label );
347 else printf( "??? " );
348 printf( " total: %11lu, recent: %lu\n",
349 (unsigned long)(pMUD->counts[0]), (unsigned long)(pMUD->counts[1]) );
350 break;
351 }
352 return( 1 );
353}
354
355
356int
357MUD_SEC_GEN_IND_VAR_proc( MUD_OPT op, BUF* pBuf, MUD_SEC_GEN_IND_VAR* pMUD )
358{
359 int size;
360
361 switch( op )
362 {
363 case MUD_FREE:
364 _free( pMUD->name );
365 _free( pMUD->description );
366 _free( pMUD->units );
367 break;
368 case MUD_DECODE:
369 decode_double( pBuf, &pMUD->low );
370 decode_double( pBuf, &pMUD->high );
371 decode_double( pBuf, &pMUD->mean );
372 decode_double( pBuf, &pMUD->stddev );
373 decode_double( pBuf, &pMUD->skewness );
374 decode_str( pBuf, &pMUD->name );
375 decode_str( pBuf, &pMUD->description );
376 decode_str( pBuf, &pMUD->units );
377 break;
378 case MUD_ENCODE:
379 encode_double( pBuf, &pMUD->low );
380 encode_double( pBuf, &pMUD->high );
381 encode_double( pBuf, &pMUD->mean );
382 encode_double( pBuf, &pMUD->stddev );
383 encode_double( pBuf, &pMUD->skewness );
384 encode_str( pBuf, &pMUD->name );
385 encode_str( pBuf, &pMUD->description );
386 encode_str( pBuf, &pMUD->units );
387 break;
388 case MUD_GET_SIZE:
389 size = 5*sizeof( double );
390 size += sizeof( MUD_STR_LEN_TYPE ) + _strlen( pMUD->name );
391 size += sizeof( MUD_STR_LEN_TYPE ) + _strlen( pMUD->description );
392 size += sizeof( MUD_STR_LEN_TYPE ) + _strlen( pMUD->units );
393 return( size );
394 case MUD_SHOW:
395 printf( " MUD_SEC_GEN_IND_VAR: \n" );
396 printf( " mean:[%.10f], stddev:[%.10f], skewness:[%.10f]\n",
397 pMUD->mean, pMUD->stddev, pMUD->skewness );
398 printf( " low:[%.10f], high:[%.10f]\n", pMUD->low, pMUD->high );
399 if( pMUD->name ) printf( " name:\"%s\"\n", pMUD->name );
400 if( pMUD->description ) printf( " description:\"%s\"\n", pMUD->description );
401 if( pMUD->units ) printf( " units:\"%s\"\n", pMUD->units );
402 break;
403 case MUD_HEADS:
404 printf( "Independent variable: " );
405 if( pMUD->name ) printf( "%s\n", pMUD->name );
406 if( pMUD->description )
407 printf( " description: %s\n", pMUD->description );
408 printf( " mean: %.9lf, stddev: %.9lf, skewness: %.9lf\n",
409 pMUD->mean, pMUD->stddev, pMUD->skewness );
410 printf( " low: %.9lf, high: %.9lf, ", pMUD->low, pMUD->high );
411 if( pMUD->units ) printf( "units: %s\n", pMUD->units );
412 break;
413 }
414 return( 1 );
415}
416
417
418int
419MUD_SEC_GEN_ARRAY_proc( MUD_OPT op, BUF* pBuf, MUD_SEC_GEN_ARRAY* pMUD )
420{
421 int size;
422 int i;
423
424 switch( op )
425 {
426 case MUD_FREE:
427 _free( pMUD->pData );
428 if( pMUD->hasTime ) _free( pMUD->pTime );
429 break;
430 case MUD_DECODE:
431 decode_4( pBuf, &pMUD->num );
432 decode_4( pBuf, &pMUD->elemSize );
433 decode_4( pBuf, &pMUD->type );
434 decode_4( pBuf, &pMUD->hasTime );
435 decode_4( pBuf, &pMUD->nBytes );
436 pMUD->pData = (caddr_t)zalloc( pMUD->num*pMUD->elemSize );
437 switch( pMUD->type )
438 {
439 case 1:
440 _decode_obj( pBuf, pMUD->pData, pMUD->nBytes );
441 break;
442 case 2:
443 switch( pMUD->elemSize )
444 {
445 case 4:
446 for( i = 0; i < pMUD->num; i++ )
447 {
448 decode_float( pBuf, &(((float*)pMUD->pData)[i]) );
449 }
450 break;
451 case 8:
452 for( i = 0; i < pMUD->num; i++ )
453 {
454 decode_double( pBuf, &(((double*)pMUD->pData)[i]) );
455 }
456 break;
457 }
458 break;
459 case 3:
460 _decode_obj( pBuf, pMUD->pData, pMUD->nBytes );
461 break;
462 }
463 if( pMUD->hasTime )
464 {
465 pMUD->pTime = (TIME*)zalloc( pMUD->num*sizeof(TIME) );
466 for( i = 0; i < pMUD->num; i++ )
467 {
468 decode_4( pBuf, &(((UINT32*)pMUD->pTime)[i]) );
469 }
470 }
471 break;
472 case MUD_ENCODE:
473 encode_4( pBuf, &pMUD->num );
474 encode_4( pBuf, &pMUD->elemSize );
475 encode_4( pBuf, &pMUD->type );
476 encode_4( pBuf, &pMUD->hasTime );
477 encode_4( pBuf, &pMUD->nBytes );
478 switch( pMUD->type )
479 {
480 case 1:
481 _encode_obj( pBuf, pMUD->pData, pMUD->nBytes );
482 break;
483 case 2:
484 switch( pMUD->elemSize )
485 {
486 case 4:
487 for( i = 0; i < pMUD->num; i++ )
488 {
489 encode_float( pBuf, &(((float*)pMUD->pData)[i]) );
490 }
491 break;
492 case 8:
493 for( i = 0; i < pMUD->num; i++ )
494 {
495 encode_double( pBuf, &(((double*)pMUD->pData)[i]) );
496 }
497 break;
498 }
499 break;
500 case 3:
501 _encode_obj( pBuf, pMUD->pData, pMUD->nBytes );
502 break;
503 }
504 if( pMUD->hasTime )
505 {
506 for( i = 0; i < pMUD->num; i++ )
507 {
508 encode_4( pBuf, &(((UINT32*)pMUD->pTime)[i]) );
509 }
510 }
511 break;
512 case MUD_GET_SIZE:
513 size = 4*sizeof( UINT32 ) + sizeof( BOOL );
514 size += pMUD->nBytes;
515 if( pMUD->hasTime )
516 {
517 size += pMUD->num*sizeof(TIME);
518 }
519 return( size );
520 case MUD_SHOW:
521 printf( " MUD_SEC_GEN_ARRAY: \n" );
522 printf( " num:[%ld], elemSize:[%ld], type:[%ld], hasTime:[%ld], nBytes:[%ld]\n",
523 (long)(pMUD->num), (long)(pMUD->elemSize), (long)(pMUD->type), (long)(pMUD->hasTime),
524 (long)(pMUD->nBytes) );
525 break;
526 case MUD_HEADS:
527 break;
528 }
529 return( 1 );
530}
531
532
533int
534MUD_SEC_GEN_HIST_pack( int num, int inBinSize, void* inHist, int outBinSize, void* outHist )
535{
536 pack_op = PACK_OP;
537 return( MUD_SEC_GEN_HIST_dopack( num, inBinSize, inHist, outBinSize, outHist ) );
538}
539
540int
541MUD_SEC_GEN_HIST_unpack( int num, int inBinSize, void* inHist, int outBinSize, void* outHist )
542{
543 pack_op = UNPACK_OP;
544 return( MUD_SEC_GEN_HIST_dopack( num, inBinSize, inHist, outBinSize, outHist ) );
545}
546
547static int
548MUD_SEC_GEN_HIST_dopack( int num, int inBinSize, void* inHist, int outBinSize, void* outHist )
549{
550 int i;
551 int outLen = 0;
552 MUD_VAR_BIN_LEN_TYPE num_temp;
553 int bin, inLoc, outLoc;
554 int outLen_temp;
555 MUD_VAR_BIN_SIZ_TYPE outBinSize_now, outBinSize_next;
556 MUD_VAR_BIN_SIZ_TYPE inBinSize_temp;
557 UINT8 c, *pc;
558 UINT16 s, *ps, *ps2;
559 UINT32 l, *pl, *pl2;
560
561
562#ifdef DEBUG
563
564 switch( pack_op )
565 {
566 case PACK_OP:
567 printf("MUD_SEC_GEN_HIST_dopack (pack) starting with \n");
568 break;
569 case UNPACK_OP:
570 printf("MUD_SEC_GEN_HIST_dopack (unpack) starting with \n");
571 break;
572 }
573 printf(" num: %d, inBinSize: %d, outBinSize: %d\n",
574 num,inBinSize,outBinSize);
575
576#endif /* DEBUG */
577
578 if( inBinSize == 1 && outBinSize == 1 )
579 {
580 bcopy( inHist, outHist, num );
581 outLen = num*outBinSize;
582 }
583 else if( inBinSize == 2 && outBinSize == 2 )
584 {
585 ps = (UINT16*)inHist;
586 ps2 = (UINT16*)outHist;
587 switch( pack_op )
588 {
589 case PACK_OP:
590 for( i = 0; i < num; i++ )
591 {
592 bencode_2( ps2, ps ); ps2++; ps++;
593 }
594 break;
595 case UNPACK_OP:
596 for( i = 0; i < num; i++ )
597 {
598 bdecode_2( ps, ps2 ); ps++; ps2++;
599 }
600 break;
601 }
602 outLen = num*outBinSize;
603 }
604 else if( inBinSize == 4 && outBinSize == 4 )
605 {
606 pl = (UINT32*)inHist;
607 pl2 = (UINT32*)outHist;
608 switch( pack_op )
609 {
610 case PACK_OP:
611 for( i = 0; i < num; i++ )
612 {
613 bencode_4( pl2, pl ); pl2++; pl++;
614 }
615 break;
616 case UNPACK_OP:
617 for( i = 0; i < num; i++ )
618 {
619 bdecode_4( pl, pl2 ); pl++; pl2++;
620 }
621 break;
622 }
623 outLen = num*outBinSize;
624 }
625 else if( inBinSize == 1 && outBinSize == 2 )
626 {
627 pc = (UINT8*)inHist;
628 ps = (UINT16*)outHist;
629 switch( pack_op )
630 {
631 case PACK_OP:
632 for( i = 0; i < num; i++ )
633 {
634 bcopy( pc, &c, 1 );
635 s = (UINT16)c;
636 bencode_2( ps, &s );
637 ps++; pc++;
638 }
639 break;
640 case UNPACK_OP:
641 for( i = 0; i < num; i++ )
642 {
643 bdecode_1( pc, &c );
644 s = (UINT16)c;
645 bcopy( &s, ps, 2 );
646 ps++; pc++;
647 }
648 break;
649 }
650 outLen = num*outBinSize;
651 }
652 else if( inBinSize == 1 && outBinSize == 4 )
653 {
654 pc = (UINT8*)inHist;
655 pl = (UINT32*)outHist;
656 switch( pack_op )
657 {
658 case PACK_OP:
659 for( i = 0; i < num; i++ )
660 {
661 bcopy( pc, &c, 1 );
662 l = (UINT32)c;
663 bencode_4( pl, &l );
664 pl++; pc++;
665 }
666 break;
667 case UNPACK_OP:
668 for( i = 0; i < num; i++ )
669 {
670 bdecode_1( pc, &c );
671 l = (UINT32)c;
672 bcopy( &l, pl, 4 );
673 pl++; pc++;
674 }
675 break;
676 }
677 outLen = num*outBinSize;
678 }
679 else if( inBinSize == 2 && outBinSize == 1 )
680 {
681 ps = (UINT16*)inHist;
682 pc = (UINT8*)outHist;
683 switch( pack_op )
684 {
685 case PACK_OP:
686 for( i = 0; i < num; i++ )
687 {
688 bcopy( ps, &s, 2 );
689 c = (UINT8)s;
690 bencode_1( pc, &c );
691 ps++; pc++;
692 }
693 break;
694 case UNPACK_OP:
695 for( i = 0; i < num; i++ )
696 {
697 bdecode_2( ps, &s );
698 c = (UINT8)s;
699 bcopy( &c, pc, 1 );
700 ps++; pc++;
701 }
702 break;
703 }
704 outLen = num*outBinSize;
705 }
706 else if( inBinSize == 2 && outBinSize == 4 )
707 {
708 ps = (UINT16*)inHist;
709 pl = (UINT32*)outHist;
710 switch( pack_op )
711 {
712 case PACK_OP:
713 for( i = 0; i < num; i++ )
714 {
715 bcopy( ps, &s, 2 );
716 l = (UINT32)s;
717 bencode_4( pl, &l );
718 pl++; ps++;
719 }
720 break;
721 case UNPACK_OP:
722 for( i = 0; i < num; i++ )
723 {
724 bdecode_2( ps, &s );
725 l = (UINT32)s;
726 bcopy( &l, pl, 4 );
727 pl++; ps++;
728 }
729 break;
730 }
731 outLen = num*outBinSize;
732 }
733 else if( inBinSize == 4 && outBinSize == 1 )
734 {
735 pl = (UINT32*)inHist;
736 pc = (UINT8*)outHist;
737 switch( pack_op )
738 {
739 case PACK_OP:
740 for( i = 0; i < num; i++ )
741 {
742 bcopy( pl, &l, 4 );
743 c = (UINT8)l;
744 bencode_1( pc, &c );
745 pl++; pc++;
746 }
747 break;
748 case UNPACK_OP:
749 for( i = 0; i < num; i++ )
750 {
751 bdecode_4( pl, &l );
752 c = (UINT8)l;
753 bcopy( &c, pc, 1 );
754 pl++; pc++;
755 }
756 break;
757 }
758 outLen = num*outBinSize;
759 }
760 else if( inBinSize == 4 && outBinSize == 2 )
761 {
762 pl = (UINT32*)inHist;
763 ps = (UINT16*)outHist;
764 switch( pack_op )
765 {
766 case PACK_OP:
767 for( i = 0; i < num; i++ )
768 {
769 bcopy( pl, &l, 4 );
770 s = (UINT16)l;
771 bencode_2( ps, &s );
772 pl++; ps++;
773 }
774 break;
775 case UNPACK_OP:
776 for( i = 0; i < num; i++ )
777 {
778 bdecode_4( pl, &l );
779 s = (UINT16)l;
780 bcopy( &s, ps, 2 );
781 pl++; ps++;
782 }
783 break;
784 }
785 outLen = num*outBinSize;
786 }
787 else if( inBinSize == 0 )
788 {
789 bin = 0;
790 inLoc = 0;
791 outLoc = 0;
792 while( bin < num )
793 {
794 switch( pack_op )
795 {
796 case PACK_OP:
797 bcopy( &((char*)inHist)[inLoc], &num_temp, 2 );
798 break;
799 case UNPACK_OP:
800 bdecode_2( &((char*)inHist)[inLoc], &num_temp );
801 break;
802 }
803 inLoc += 2;
804
805 bcopy( &((char*)inHist)[inLoc], &inBinSize_temp, 1 );
806 inLoc += 1;
807
808#ifdef DEBUG
809 printf( "unpacking %d bins of %d bytes\n", num_temp,
810 inBinSize_temp );
811#endif /* DEBUG */
812
813 outLen_temp = num_temp*outBinSize;
814
815 if( inBinSize_temp == 0 )
816 {
817 bzero( &((char*)outHist)[outLoc], outLen_temp );
818 }
819 else
820 {
821 switch( pack_op )
822 {
823 case PACK_OP:
824 MUD_SEC_GEN_HIST_pack( num_temp,
825 inBinSize_temp, (void*)&((char*)inHist)[inLoc],
826 outBinSize, (void*)&((char*)outHist)[outLoc] );
827 break;
828 case UNPACK_OP:
829 MUD_SEC_GEN_HIST_unpack( num_temp,
830 inBinSize_temp, (void*)&((char*)inHist)[inLoc],
831 outBinSize, (void*)&((char*)outHist)[outLoc] );
832 break;
833 }
834 inLoc += num_temp*inBinSize_temp;
835 }
836
837 outLoc += outLen_temp;
838 bin += num_temp;
839 }
840 outLen = num*outBinSize;
841 }
842 else if( outBinSize == 0 )
843 {
844 bin = 0;
845 inLoc = 0;
846 outLoc = 0;
847 outBinSize_now = n_bytes_needed( varBinArray( inHist, inBinSize, 0 ) );
848
849 while( bin < num )
850 {
851 next_few_bins( num - bin, inBinSize, &((char*)inHist)[inLoc],
852 outBinSize_now, &num_temp, &outBinSize_next );
853
854#ifdef DEBUG
855 printf("\n");
856 printf("MUD_SEC_GEN_HIST_DOPACK - packing %d bins of %d bytes\n",
857 num_temp, outBinSize_now );
858 printf("\n");
859#endif /* DEBUG */
860
861 switch( pack_op )
862 {
863 case PACK_OP:
864 bencode_2( &((char*)outHist)[outLoc], &num_temp );
865 break;
866 case UNPACK_OP:
867 bcopy( &num_temp, &((char*)outHist)[outLoc], 2 );
868 break;
869 }
870 outLoc += 2;
871
872 bcopy( &outBinSize_now, &((char*)outHist)[outLoc], 1 );
873 outLoc += 1;
874
875 if( outBinSize_now != 0 )
876 {
877 switch( pack_op )
878 {
879 case PACK_OP:
880 MUD_SEC_GEN_HIST_pack( num_temp,
881 inBinSize, (void*)&((char*)inHist)[inLoc],
882 outBinSize_now, (void*)&((char*)outHist)[outLoc] );
883 break;
884 case UNPACK_OP:
885 MUD_SEC_GEN_HIST_unpack( num_temp,
886 inBinSize, (void*)&((char*)inHist)[inLoc],
887 outBinSize_now, (void*)&((char*)outHist)[outLoc] );
888 break;
889 }
890 outLoc += num_temp*outBinSize_now;
891 }
892
893 outBinSize_now = outBinSize_next;
894 inLoc += num_temp*inBinSize;
895 bin += num_temp;
896 }
897 outLen = outLoc;
898 }
899
900 return( outLen );
901}
902
903
904static int
905n_bytes_needed( UINT32 val )
906{
907 if( val & 0xFFFF0000 ) return( 4 );
908 else if( val & 0x0000FF00 ) return( 2 );
909 else if( val & 0x000000FF ) return( 1 );
910 else return( 0 );
911}
912
913
914static UINT32
915varBinArray( void* pHistData, int binSize, int index )
916{
917 UINT8 c;
918 UINT16 s;
919 UINT32 l;
920
921 switch( pack_op )
922 {
923 case PACK_OP:
924 switch( binSize )
925 {
926 case 1:
927 bcopy( &((UINT8*)pHistData)[index], &c, 1 );
928 return( c );
929 case 2:
930 bcopy( &((UINT16*)pHistData)[index], &s, 2 );
931 return( s );
932 case 4:
933 bcopy( &((UINT32*)pHistData)[index], &l, 4 );
934 return( l );
935 }
936 break;
937 case UNPACK_OP:
938 switch( binSize )
939 {
940 case 1:
941 bdecode_1( &((UINT8*)pHistData)[index], &c );
942 return( c );
943 case 2:
944 bdecode_2( &((UINT16*)pHistData)[index], &s );
945 return( s );
946 case 4:
947 bdecode_4( &((UINT32*)pHistData)[index], &l );
948 return( l );
949 }
950 break;
951 }
952 return( 0 );
953}
954
955
956static void
957next_few_bins( int num_tot, int inBinSize, void* pHistData, int outBinSize_now,
958 MUD_VAR_BIN_LEN_TYPE* pNum_next, MUD_VAR_BIN_SIZ_TYPE* pOutBinSize_next )
959{
960 int val;
961 MUD_VAR_BIN_LEN_TYPE num_next;
962 MUD_VAR_BIN_LEN_TYPE num_nextLower;
963 MUD_VAR_BIN_SIZ_TYPE outBinSize_next;
964 MUD_VAR_BIN_SIZ_TYPE outBinSize_nextLower;
965 MUD_VAR_BIN_SIZ_TYPE outBinSize_nextLowerFirst;
966 int bytesNextLower;
967 int bytesNextLowerDoNow;
968
969/* Maximum of 16 bits for num_next; must break up storage into pieces
970 of maximum length 65535 or num_next becomes negative */
971
972 MUD_VAR_BIN_LEN_TYPE temp_next; /* needed to check for overflow */
973
974#ifdef DEBUG
975 printf("Next_few_bins starting with num_tot: %d\n",num_tot);
976#endif /* DEBUG */
977
978 num_next = num_nextLower = 0;
979 outBinSize_nextLowerFirst = outBinSize_nextLower = outBinSize_next =
980 outBinSize_now;
981 bytesNextLower = bytesNextLowerDoNow = 0;
982
983
984 while( num_next < num_tot )
985 {
986 /* check for overflow of short int. Turns negative if > 65535
987 Have to store data in chunks of maximum length 65535 */
988 temp_next = num_next + 1 ;
989 if (temp_next < num_next ) {
990
991#ifdef DEBUG
992 printf ("Next_few_bins: num_next will overflow; num_next: %d\n",
993 num_next);
994 printf (" Breaking out of Next_few_bins ... \n");
995#endif /* DEBUG */
996
997 break;
998 }
999
1000 val = varBinArray( pHistData, inBinSize, num_next );
1001 outBinSize_next = n_bytes_needed( val );
1002 if( outBinSize_next == outBinSize_now )
1003 {
1004 num_next++;
1005 if( num_nextLower != 0 )
1006 {
1007 num_nextLower = 0;
1008 outBinSize_nextLowerFirst = outBinSize_nextLower = outBinSize_now;
1009 bytesNextLower = bytesNextLowerDoNow = 0;
1010 }
1011 }
1012 else if( outBinSize_next < outBinSize_now )
1013 {
1014 if( outBinSize_nextLowerFirst == outBinSize_now )
1015 outBinSize_nextLowerFirst = outBinSize_next;
1016
1017 if( outBinSize_nextLower != outBinSize_next )
1018 {
1019 bytesNextLower += sizeof( MUD_VAR_BIN_LEN_TYPE ) +
1020 sizeof( MUD_VAR_BIN_SIZ_TYPE ) +
1021 outBinSize_next;
1022 outBinSize_nextLower = outBinSize_next;
1023 }
1024 else
1025 {
1026 bytesNextLower += outBinSize_next;
1027 }
1028 bytesNextLowerDoNow += outBinSize_now;
1029
1030 if( bytesNextLowerDoNow < ( bytesNextLower +
1031 sizeof( MUD_VAR_BIN_LEN_TYPE ) +
1032 sizeof( MUD_VAR_BIN_SIZ_TYPE ) ) )
1033 {
1034 num_next++;
1035 num_nextLower++;
1036 }
1037 else
1038 {
1039 num_next -= num_nextLower;
1040 outBinSize_next = outBinSize_nextLowerFirst;
1041 break;
1042 }
1043 }
1044 else break;
1045 }
1046
1047 *pOutBinSize_next = outBinSize_next;
1048 *pNum_next = num_next;
1049}
1050
1051
MUD_STR_LEN_TYPE
UINT16 MUD_STR_LEN_TYPE
Definition mud.h:474
UINT16
unsigned short UINT16
Definition mud.h:140
UINT32
unsigned long UINT32
Definition mud.h:146
MUD_VAR_BIN_SIZ_TYPE
UINT8 MUD_VAR_BIN_SIZ_TYPE
Definition mud.h:476
_decode_obj
#define _decode_obj(b, p, s)
Definition mud.h:444
MUD_VAR_BIN_LEN_TYPE
UINT16 MUD_VAR_BIN_LEN_TYPE
Definition mud.h:475
zalloc
#define zalloc(n)
Definition mud.h:201
MUD_OPT
MUD_OPT
Definition mud.h:207
MUD_FREE
@ MUD_FREE
Definition mud.h:210
MUD_ENCODE
@ MUD_ENCODE
Definition mud.h:208
MUD_HEADS
@ MUD_HEADS
Definition mud.h:213
MUD_SHOW
@ MUD_SHOW
Definition mud.h:212
MUD_GET_SIZE
@ MUD_GET_SIZE
Definition mud.h:211
MUD_DECODE
@ MUD_DECODE
Definition mud.h:209
bencode_1
#define bencode_1(b, p)
Definition mud.h:442
bdecode_1
#define bdecode_1(b, p)
Definition mud.h:441
_encode_obj
#define _encode_obj(b, p, s)
Definition mud.h:446
encode_4
#define encode_4(b, p)
Definition mud.h:456
_free
#define _free(objp)
Definition mud.h:198
decode_4
#define decode_4(b, p)
Definition mud.h:454
_strlen
#define _strlen(s)
Definition mud.h:193
UINT8
unsigned char UINT8
Definition mud.h:138
BOOL
UINT32 BOOL
Definition mud.h:157
_ANSI_ARGS_
#define _ANSI_ARGS_(x)
Definition mud.h:483
TIME
UINT32 TIME
Definition mud.h:154
encode_str
void encode_str(BUF *pB, char **ps)
Definition mud_encode.c:140
encode_float
void encode_float(BUF *pBuf, float *fp)
Definition mud_encode.c:244
bencode_4
void bencode_4(void *b, void *p)
Definition mud_encode.c:73
bdecode_4
void bdecode_4(void *b, void *p)
Definition mud_encode.c:60
encode_double
void encode_double(BUF *pBuf, double *fp)
Definition mud_encode.c:407
bencode_2
void bencode_2(void *b, void *p)
Definition mud_encode.c:41
decode_double
void decode_double(BUF *pBuf, double *fp)
Definition mud_encode.c:454
bdecode_2
void bdecode_2(void *b, void *p)
Definition mud_encode.c:28
decode_str
void decode_str(BUF *pB, char **ps)
Definition mud_encode.c:115
decode_float
void decode_float(BUF *pBuf, float *fp)
Definition mud_encode.c:293
MUD_SEC_GEN_ARRAY_proc
int MUD_SEC_GEN_ARRAY_proc(MUD_OPT op, BUF *pBuf, MUD_SEC_GEN_ARRAY *pMUD)
Definition mud_gen.c:419
n_bytes_needed
static int n_bytes_needed(UINT32 val)
Definition mud_gen.c:905
varBinArray
static UINT32 varBinArray(void *pHistData, int binSize, int index)
Definition mud_gen.c:915
MUD_SEC_GEN_HIST_HDR_proc
int MUD_SEC_GEN_HIST_HDR_proc(MUD_OPT op, BUF *pBuf, MUD_SEC_GEN_HIST_HDR *pMUD)
Definition mud_gen.c:196
UNPACK_OP
#define UNPACK_OP
Definition mud_gen.c:35
MUD_SEC_GEN_SCALER_proc
int MUD_SEC_GEN_SCALER_proc(MUD_OPT op, BUF *pBuf, MUD_SEC_GEN_SCALER *pMUD)
Definition mud_gen.c:316
MUD_SEC_GEN_IND_VAR_proc
int MUD_SEC_GEN_IND_VAR_proc(MUD_OPT op, BUF *pBuf, MUD_SEC_GEN_IND_VAR *pMUD)
Definition mud_gen.c:357
MUD_SEC_GEN_HIST_DAT_proc
int MUD_SEC_GEN_HIST_DAT_proc(MUD_OPT op, BUF *pBuf, MUD_SEC_GEN_HIST_DAT *pMUD)
Definition mud_gen.c:283
PACK_OP
#define PACK_OP
Definition mud_gen.c:34
MUD_SEC_GEN_RUN_DESC_proc
int MUD_SEC_GEN_RUN_DESC_proc(MUD_OPT op, BUF *pBuf, MUD_SEC_GEN_RUN_DESC *pMUD)
Definition mud_gen.c:45
MUD_SEC_GEN_HIST_pack
int MUD_SEC_GEN_HIST_pack(int num, int inBinSize, void *inHist, int outBinSize, void *outHist)
Definition mud_gen.c:534
pack_op
static int pack_op
Definition mud_gen.c:36
MUD_SEC_GEN_HIST_dopack
static int MUD_SEC_GEN_HIST_dopack(int num, int inBinSize, void *inHist, int outBinSize, void *outHist)
Definition mud_gen.c:548
next_few_bins
static void next_few_bins(int num_tot, int inBinSize, void *pHistData, int outBinSize_now, MUD_VAR_BIN_LEN_TYPE *pNum_next, MUD_VAR_BIN_SIZ_TYPE *pOutBinSize_next)
Definition mud_gen.c:957
MUD_SEC_GEN_HIST_unpack
int MUD_SEC_GEN_HIST_unpack(int num, int inBinSize, void *inHist, int outBinSize, void *outHist)
Definition mud_gen.c:541
BUF
Definition mud.h:253
MUD_SEC_GEN_ARRAY
Definition mud.h:363
MUD_SEC_GEN_ARRAY::pData
caddr_t pData
Definition mud.h:371
MUD_SEC_GEN_ARRAY::hasTime
BOOL hasTime
Definition mud.h:369
MUD_SEC_GEN_ARRAY::num
UINT32 num
Definition mud.h:366
MUD_SEC_GEN_ARRAY::nBytes
UINT32 nBytes
Definition mud.h:370
MUD_SEC_GEN_ARRAY::pTime
TIME * pTime
Definition mud.h:372
MUD_SEC_GEN_ARRAY::type
UINT32 type
Definition mud.h:368
MUD_SEC_GEN_ARRAY::elemSize
UINT32 elemSize
Definition mud.h:367
MUD_SEC_GEN_HIST_DAT
Definition mud.h:354
MUD_SEC_GEN_HIST_DAT::nBytes
UINT32 nBytes
Definition mud.h:357
MUD_SEC_GEN_HIST_DAT::pData
caddr_t pData
Definition mud.h:358
MUD_SEC_GEN_HIST_HDR
Definition mud.h:334
MUD_SEC_GEN_HIST_HDR::bkgd1
UINT32 bkgd1
Definition mud.h:346
MUD_SEC_GEN_HIST_HDR::title
char * title
Definition mud.h:349
MUD_SEC_GEN_HIST_HDR::nBins
UINT32 nBins
Definition mud.h:339
MUD_SEC_GEN_HIST_HDR::nEvents
UINT32 nEvents
Definition mud.h:348
MUD_SEC_GEN_HIST_HDR::bytesPerBin
UINT32 bytesPerBin
Definition mud.h:340
MUD_SEC_GEN_HIST_HDR::fsPerBin
UINT32 fsPerBin
Definition mud.h:341
MUD_SEC_GEN_HIST_HDR::t0_ps
UINT32 t0_ps
Definition mud.h:342
MUD_SEC_GEN_HIST_HDR::nBytes
UINT32 nBytes
Definition mud.h:338
MUD_SEC_GEN_HIST_HDR::histType
UINT32 histType
Definition mud.h:337
MUD_SEC_GEN_HIST_HDR::bkgd2
UINT32 bkgd2
Definition mud.h:347
MUD_SEC_GEN_HIST_HDR::t0_bin
UINT32 t0_bin
Definition mud.h:343
MUD_SEC_GEN_HIST_HDR::goodBin2
UINT32 goodBin2
Definition mud.h:345
MUD_SEC_GEN_HIST_HDR::goodBin1
UINT32 goodBin1
Definition mud.h:344
MUD_SEC_GEN_IND_VAR
Definition mud.h:384
MUD_SEC_GEN_IND_VAR::low
double low
Definition mud.h:387
MUD_SEC_GEN_IND_VAR::name
char * name
Definition mud.h:392
MUD_SEC_GEN_IND_VAR::units
char * units
Definition mud.h:394
MUD_SEC_GEN_IND_VAR::description
char * description
Definition mud.h:393
MUD_SEC_GEN_IND_VAR::skewness
double skewness
Definition mud.h:391
MUD_SEC_GEN_IND_VAR::mean
double mean
Definition mud.h:389
MUD_SEC_GEN_IND_VAR::high
double high
Definition mud.h:388
MUD_SEC_GEN_IND_VAR::stddev
double stddev
Definition mud.h:390
MUD_SEC_GEN_RUN_DESC
Definition mud.h:311
MUD_SEC_GEN_RUN_DESC::title
char * title
Definition mud.h:319
MUD_SEC_GEN_RUN_DESC::temperature
char * temperature
Definition mud.h:329
MUD_SEC_GEN_RUN_DESC::apparatus
char * apparatus
Definition mud.h:323
MUD_SEC_GEN_RUN_DESC::experimenter
char * experimenter
Definition mud.h:328
MUD_SEC_GEN_RUN_DESC::das
char * das
Definition mud.h:327
MUD_SEC_GEN_RUN_DESC::exptNumber
UINT32 exptNumber
Definition mud.h:314
MUD_SEC_GEN_RUN_DESC::lab
char * lab
Definition mud.h:320
MUD_SEC_GEN_RUN_DESC::timeBegin
TIME timeBegin
Definition mud.h:316
MUD_SEC_GEN_RUN_DESC::timeEnd
TIME timeEnd
Definition mud.h:317
MUD_SEC_GEN_RUN_DESC::area
char * area
Definition mud.h:321
MUD_SEC_GEN_RUN_DESC::insert
char * insert
Definition mud.h:324
MUD_SEC_GEN_RUN_DESC::runNumber
UINT32 runNumber
Definition mud.h:315
MUD_SEC_GEN_RUN_DESC::sample
char * sample
Definition mud.h:325
MUD_SEC_GEN_RUN_DESC::elapsedSec
UINT32 elapsedSec
Definition mud.h:318
MUD_SEC_GEN_RUN_DESC::orient
char * orient
Definition mud.h:326
MUD_SEC_GEN_RUN_DESC::method
char * method
Definition mud.h:322
MUD_SEC_GEN_RUN_DESC::field
char * field
Definition mud.h:330
MUD_SEC_GEN_SCALER
Definition mud.h:376
MUD_SEC_GEN_SCALER::counts
UINT32 counts[2]
Definition mud.h:379
MUD_SEC_GEN_SCALER::label
char * label
Definition mud.h:380