AlcapDAQ  1
Macros | Typedefs | Functions | Variables
overall.cpp File Reference
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <endian.h>
#include <byteswap.h>
#include <ctype.h>
#include "midas.h"
#include <zlib.h>
#include "mucap_structures.h"
#include "mucap_compress.h"

Go to the source code of this file.

Macros

#define le32_to_cpu(i)   (i)
 

Typedefs

typedef int(* comp_fcn )(void *input, int input_size, unsigned char *output, int userParam)
 
typedef int(* expand_fcn )(unsigned char *input, int input_size, void *output, int userParam)
 

Functions

int read_midas_event (FILE *fp, char *pevent)
 
void compress_bank (void *input_data, int input_size, void *output_event, char *output_name, comp_fcn f, int userParam)
 
void compress_event (void *input_event, void *output_event, bool USE_OLD_COMPRESSION)
 
void compress_event_skim (void *input_event, void *output_event, bool keep_etc, bool USE_OLD_COMPRESSION)
 
void expand_bank (unsigned char *input_data, int input_size, void *output_event, char *output_name, expand_fcn f, int userParam)
 
void expand_event (void *input_event, void *output_event, bool USE_OLD_COMPRESSION)
 
void compress_load_all (bool USE_OLD_COMPRESSION)
 
void compress_optimize_all (bool USE_OLD_COMPRESSION)
 
void compress_optimize_skim ()
 

Variables

static int verbose = 0
 

Macro Definition Documentation

#define le32_to_cpu (   i)    (i)

Definition at line 16 of file overall.cpp.

Referenced by read_midas_event().

Typedef Documentation

typedef int(* comp_fcn)(void *input, int input_size, unsigned char *output, int userParam)

Definition at line 44 of file overall.cpp.

typedef int(* expand_fcn)(unsigned char *input, int input_size, void *output, int userParam)

Definition at line 253 of file overall.cpp.

Function Documentation

void compress_bank ( void *  input_data,
int  input_size,
void *  output_event,
char *  output_name,
comp_fcn  f,
int  userParam 
)

Definition at line 46 of file overall.cpp.

References printf(), and verbose.

Referenced by compress_event(), and compress_event_skim().

49 {
50  unsigned char *compressed_bank;
51  bk_create(output_event, output_name, TID_BYTE, &compressed_bank);
52 
53  // compress the bank
54  int compressed_size = (*f) (input_data, input_size, compressed_bank, userParam);
55 
56  // compute checksum
57  int *checksum_ptr = (int *) &compressed_bank[compressed_size];
58  *checksum_ptr = adler32(0x5555, (unsigned char *) input_data, input_size);
59  // printf("checksum = 0x%x\n", *checksum_ptr);
60 
61  bk_close(output_event, compressed_bank + compressed_size + sizeof(int));
62 
63  if(verbose) {
64  printf("%s: %d %d %0.3f\n", output_name, input_size, compressed_size,
65  ((double) compressed_size)/input_size);
66  }
67 }
void compress_event ( void *  input_event,
void *  output_event,
bool  USE_OLD_COMPRESSION 
)

Definition at line 69 of file overall.cpp.

References caen_compress(), cmp_compress(), compress_bank(), fadc_compress(), n2fadc_ndet_compress(), n2fadc_tpc_compress(), nfadc_compress(), printf(), should_compress_caen, should_compress_comp, should_compress_fadc, should_compress_n2fadc_ndet, should_compress_n2fadc_tpc, should_compress_nfadc, should_compress_tdc400, sprintf(), and tdc400_compress().

Referenced by eb_user(), and main().

70 {
71  // If it's not a 32-bit event, just copy from input to output
72  BANK_HEADER *bank_header = (BANK_HEADER *)input_event;
73  BOOL is_32 = (bank_header->flags & BANK_FORMAT_32BIT);
74 
75  if(!is_32) {
76  memcpy(output_event, input_event,
77  bank_header->data_size + sizeof(BANK_HEADER));
78  return;
79  }
80 
81  BANK32 *input_bank = NULL;
82  void *input_data = NULL;
83 
84  while (1) {
85  int input_size =
86  bk_iterate32(input_event, &input_bank, &input_data);
87  if (input_bank == NULL) {
88  break;
89  }
90 
91  char output_name[5];
92  if (should_compress_tdc400 && !strncmp(input_bank->name, "TDC", 3)) {
93  sprintf(output_name, "CTD%c", input_bank->name[3]);
94  compress_bank(input_data, input_size, output_event,
95  output_name, (comp_fcn) tdc400_compress, 0);
96  } else if (should_compress_fadc
97  && !strncmp(input_bank->name, "ADC", 3)) {
98  sprintf(output_name, "CAD%c", input_bank->name[3]);
99  compress_bank(input_data, input_size, output_event,
100  output_name, (comp_fcn) fadc_compress, 0);
101  } else if (USE_OLD_COMPRESSION &&
102  should_compress_nfadc
103  && input_bank->name[0] == 'N'
104  && (input_bank->name[1] == 'a' ||
105  input_bank->name[1] == 'b' ||
106  input_bank->name[1] == 'c' ||
107  input_bank->name[1] == 'd')
108  && isxdigit(input_bank->name[2])
109  && isxdigit(input_bank->name[3])) {
110  printf("Using run10 compression\n");
111  sprintf(output_name, "n%c%c%c", input_bank->name[1],
112  input_bank->name[2], input_bank->name[3]);
113  int board_number = 16*(input_bank->name[2]-'0') + (input_bank->name[3]-'0');
114  compress_bank(input_data, input_size, output_event,
115  output_name, (comp_fcn) nfadc_compress, board_number);
116  } //start paste
117  else if (!USE_OLD_COMPRESSION &&
118  input_bank->name[0] == 'N'
119  && input_bank->name[1] >= 'a'
120  && input_bank->name[1] <= 'h'
121  && isxdigit(input_bank->name[2])
122  && isxdigit(input_bank->name[3])) {
123  printf("Using run11+ compression\n");
124  sprintf(output_name, "n%c%c%c", input_bank->name[1],
125  input_bank->name[2], input_bank->name[3]);
126  int board_number = 16*(input_bank->name[2]-'0') + (input_bank->name[3]-'0');
127  if(board_number < 128 && should_compress_n2fadc_tpc) {
128  compress_bank(input_data, input_size, output_event,
129  output_name, (comp_fcn) n2fadc_tpc_compress, board_number);
130  }else if(should_compress_n2fadc_ndet) {
131  compress_bank(input_data, input_size, output_event,
132  output_name, (comp_fcn) n2fadc_ndet_compress, board_number);
133  }
134  }//end paste
135  else if (should_compress_caen
136  && !strncmp(input_bank->name, "CAE", 3)) {
137  sprintf(output_name, "CCA%c", input_bank->name[3]);
138  compress_bank(input_data, input_size, output_event,
139  output_name, (comp_fcn) caen_compress, 0);
140  } else if (should_compress_comp
141  && !strncmp(input_bank->name, "CMP", 3)) {
142  sprintf(output_name, "CCM%c", input_bank->name[3]);
143  compress_bank(input_data, input_size, output_event,
144  output_name, (comp_fcn) cmp_compress, 0);
145  } else {
146  // Otherwise: if the input and output events are not the same,
147  // just copy the bank whole.
148  if(input_event != output_event) {
149  char *output_data;
150  bk_create(output_event, input_bank->name, input_bank->type,
151  &output_data);
152  memcpy(output_data, input_data, input_size);
153  bk_close(output_event, output_data + input_size);
154  }
155  }
156  }
157 }
void compress_event_skim ( void *  input_event,
void *  output_event,
bool  keep_etc,
bool  USE_OLD_COMPRESSION 
)

Definition at line 160 of file overall.cpp.

References compress_bank(), fadc_compress(), hits_compress(), n2fadc_ndet_compress(), n2fadc_tpc_compress(), nfadc_compress(), should_compress_n2fadc_ndet, should_compress_n2fadc_tpc, should_compress_nfadc, sprintf(), and stck_compress().

161 {
162  // If it's not a 32-bit event, just copy from input to output
163  BANK_HEADER *bank_header = (BANK_HEADER *)input_event;
164  BOOL is_32 = (bank_header->flags & BANK_FORMAT_32BIT);
165 
166  if(!is_32 || EVENT_ID(input_event) != 1) {
167  memcpy(output_event, input_event,
168  bank_header->data_size + sizeof(BANK_HEADER));
169  return;
170  }
171 
172  BANK32 *input_bank = NULL;
173  void *input_data = NULL;
174 
175  while (1) {
176  int input_size =
177  bk_iterate32(input_event, &input_bank, &input_data);
178  if (input_bank == NULL) {
179  break;
180  }
181 
182  char output_name[5];
183  if (!strncmp(input_bank->name, "RTPC", 4)) {
184  compress_bank(input_data, input_size, output_event,
185  "CTPC", (comp_fcn) stck_compress, 0);
186  } else if (!strncmp(input_bank->name, "RHIT", 4)) {
187  compress_bank(input_data, input_size, output_event,
188  "HITZ", (comp_fcn) hits_compress, 0);
189  } else if (!strncmp(input_bank->name, "SKIM", 4)) {
190  // save bank of gskim triggers
191  if(input_event != output_event) {
192  char *output_data;
193  bk_create(output_event, "GSKM", input_bank->type,
194  &output_data);
195  memcpy(output_data, input_data, input_size);
196  bk_close(output_event, output_data + input_size);
197  }
198  } else if (USE_OLD_COMPRESSION &&
199  should_compress_nfadc
200  && input_bank->name[0] == 'N'
201  && (input_bank->name[1] == 'a' ||
202  input_bank->name[1] == 'b' ||
203  input_bank->name[1] == 'c' ||
204  input_bank->name[1] == 'd')
205  && isxdigit(input_bank->name[2])
206  && isxdigit(input_bank->name[3])) {
207  sprintf(output_name, "n%c%c%c", input_bank->name[1],
208  input_bank->name[2], input_bank->name[3]);
209  int board_number = 16*(input_bank->name[2]-'0') + (input_bank->name[3]-'0');
210  compress_bank(input_data, input_size, output_event,
211  output_name, (comp_fcn) nfadc_compress, board_number);
212  } //start paste
213  else if (!USE_OLD_COMPRESSION &&
214  input_bank->name[0] == 'N'
215  && input_bank->name[1] >= 'a'
216  && input_bank->name[1] <= 'h'
217  && isxdigit(input_bank->name[2])
218  && isxdigit(input_bank->name[3])) {
219  sprintf(output_name, "n%c%c%c", input_bank->name[1],
220  input_bank->name[2], input_bank->name[3]);
221  int board_number = 16*(input_bank->name[2]-'0') + (input_bank->name[3]-'0');
222  if(board_number < 128 && should_compress_n2fadc_tpc) {
223  compress_bank(input_data, input_size, output_event,
224  output_name, (comp_fcn) n2fadc_tpc_compress, board_number);
225  }else if(should_compress_n2fadc_ndet) {
226  compress_bank(input_data, input_size, output_event,
227  output_name, (comp_fcn) n2fadc_ndet_compress, board_number);
228  }
229  }//end paste
230  else if (!strncmp(input_bank->name, "ADC", 3)) {
231  sprintf(output_name, "CAD%c", input_bank->name[3]);
232  compress_bank(input_data, input_size, output_event,
233  output_name, (comp_fcn) fadc_compress, 0);
234  } else if (keep_etc && (!strncmp(input_bank->name, "LAD", 3) ||
235 
236  // !strncmp(input_bank->name, "LSPK", 4) ||
237  !strncmp(input_bank->name, "CAET", 4)))
238  {
239  // Otherwise: if the input and output events are not the same,
240  // just copy the bank whole.
241 
242  if(input_event != output_event) {
243  char *output_data;
244  bk_create(output_event, input_bank->name, input_bank->type,
245  &output_data);
246  memcpy(output_data, input_data, input_size);
247  bk_close(output_event, output_data + input_size);
248  }
249  }
250  }
251 }
void compress_load_all ( bool  USE_OLD_COMPRESSION)

Definition at line 373 of file overall.cpp.

References caen_load(), comp_load(), fadc_load(), hits_load(), n2fadc_ndet_load(), n2fadc_tpc_load(), nfadc_load(), stck_load(), and tdc400_load().

Referenced by eb_begin_of_run(), main(), MUnCompressRawData_init(), and process_file().

374 {
375  tdc400_load();
376  fadc_load();
377 
378  if (USE_OLD_COMPRESSION){
379  nfadc_load();}
380  else{
381  n2fadc_tpc_load();
382  n2fadc_ndet_load();
383  }
384  caen_load();
385  comp_load();
386  hits_load();
387  stck_load();
388 }
void compress_optimize_all ( bool  USE_OLD_COMPRESSION)

Definition at line 390 of file overall.cpp.

References caen_optimize(), comp_optimize(), fadc_optimize(), n2fadc_ndet_optimize(), n2fadc_tpc_optimize(), nfadc_optimize(), and tdc400_optimize().

Referenced by main().

391 {
392  tdc400_optimize();
393  fadc_optimize();
394  if (USE_OLD_COMPRESSION){
395  nfadc_optimize();
396  }
397  else{
398  n2fadc_tpc_optimize();
399  n2fadc_ndet_optimize();
400  }
401  caen_optimize();
402  comp_optimize();
403 }
void compress_optimize_skim ( )

Definition at line 405 of file overall.cpp.

References hits_optimize(), and stck_optimize().

406 {
407  hits_optimize();
408  stck_optimize();
409 }
void expand_bank ( unsigned char *  input_data,
int  input_size,
void *  output_event,
char *  output_name,
expand_fcn  f,
int  userParam 
)

Definition at line 255 of file overall.cpp.

References printf().

Referenced by expand_event().

257 {
258  unsigned char *uncompressed_bank;
259  int bank_type = TID_DWORD;
260  if(output_name[0] == 'N') bank_type = TID_BYTE;
261  bk_create(output_event, output_name, bank_type, &uncompressed_bank);
262 
263  // uncompress the data; "sizeof(int)" accounts for the checksum word
264  int uncompressed_size = (*f) (input_data, input_size - sizeof(int),
265  uncompressed_bank, userParam);
266 
267  // verify the Adler32 checksum
268  int checksum = adler32(0x5555, uncompressed_bank, uncompressed_size);
269  int *checksum_ptr = (int *) &input_data[input_size-sizeof(int)];
270  if(checksum != *checksum_ptr) {
271  printf("*** CHECKSUM TEST FAILED: Bank %s (0x%x -> 0x%x) ***\n",
272  output_name, *checksum_ptr, checksum);
273  } else {
274 
275  // printf("Checksum OK for bank %s (0x%x)\n", output_name, checksum);
276 
277 
278  }
279 
280  bk_close(output_event, uncompressed_bank + uncompressed_size);
281 }
void expand_event ( void *  input_event,
void *  output_event,
bool  USE_OLD_COMPRESSION 
)

Definition at line 283 of file overall.cpp.

References caen_expand(), cmp_expand(), expand_bank(), fadc_expand(), hits_expand(), n2fadc_ndet_expand(), n2fadc_tpc_expand(), nfadc_expand(), sprintf(), stck_expand(), and tdc400_expand().

Referenced by main(), MUnCompressRawData(), and process_file().

284 {
285  // If it's not a 32-bit event, just copy from input to output
286  BANK_HEADER *bank_header = (BANK_HEADER *)input_event;
287  BOOL is_32 = (bank_header->flags & BANK_FORMAT_32BIT);
288 
289  if(!is_32) {
290  memcpy(output_event, input_event,
291  bank_header->data_size + sizeof(BANK_HEADER));
292  return;
293  }
294 
295  BANK32 *input_bank = NULL;
296  unsigned char *input_data = NULL;
297 
298  while (1) {
299  int input_size =
300  bk_iterate32(input_event, &input_bank, &input_data);
301  if (input_bank == NULL) {
302  break;
303  }
304 
305  char output_name[5];
306  if (!strncmp(input_bank->name, "CTD", 3)) {
307  sprintf(output_name, "TDC%c", input_bank->name[3]);
308  expand_bank(input_data, input_size, output_event,
309  output_name, (expand_fcn) tdc400_expand, 0);
310  } else if(USE_OLD_COMPRESSION &&
311  input_bank->name[0] == 'n'
312  && (input_bank->name[1] == 'a' ||
313  input_bank->name[1] == 'b' ||
314  input_bank->name[1] == 'c' ||
315  input_bank->name[1] == 'd')
316  && isxdigit(input_bank->name[2])
317  && isxdigit(input_bank->name[3])) {
318  sprintf(output_name, "N%c%c%c", input_bank->name[1],
319  input_bank->name[2], input_bank->name[3]);
320  int board_number = 16*(input_bank->name[2]-'0') + (input_bank->name[3]-'0');
321  expand_bank(input_data, input_size, output_event,
322  output_name, (expand_fcn) nfadc_expand, board_number);
323  }
324  else if(!USE_OLD_COMPRESSION &&
325  input_bank->name[0] == 'n'
326  && input_bank->name[1] >= 'a'
327  && input_bank->name[1] <= 'h'
328  && isxdigit(input_bank->name[2])
329  && isxdigit(input_bank->name[3])) {
330  sprintf(output_name, "N%c%c%c", input_bank->name[1],
331  input_bank->name[2], input_bank->name[3]);
332  int board_number = 16*(input_bank->name[2]-'0') + (input_bank->name[3]-'0');
333  if(board_number < 128) {
334  expand_bank(input_data, input_size, output_event,
335  output_name, (expand_fcn) n2fadc_tpc_expand, board_number);
336  } else {
337  expand_bank(input_data, input_size, output_event,
338  output_name, (expand_fcn) n2fadc_ndet_expand, board_number);
339  }
340  }
341  else if (!strncmp(input_bank->name, "CAD", 3)) {
342  sprintf(output_name, "ADC%c", input_bank->name[3]);
343  expand_bank(input_data, input_size, output_event,
344  output_name, (expand_fcn) fadc_expand, 0);
345  } else if (!strncmp(input_bank->name, "CCA", 3)) {
346  sprintf(output_name, "CAE%c", input_bank->name[3]);
347  expand_bank(input_data, input_size, output_event,
348  output_name, (expand_fcn) caen_expand, 0);
349  } else if (!strncmp(input_bank->name, "CCM", 3)) {
350  sprintf(output_name, "CMP%c", input_bank->name[3]);
351  expand_bank(input_data, input_size, output_event,
352  output_name, (expand_fcn) cmp_expand, 0);
353  } else if (!strncmp(input_bank->name, "HITZ", 4)) {
354  expand_bank(input_data, input_size, output_event,
355  "HITS", (expand_fcn) hits_expand, 0);
356  } else if (!strncmp(input_bank->name, "CTPC", 4)) {
357  expand_bank(input_data, input_size, output_event,
358  "STCK", (expand_fcn) stck_expand, 0);
359  } else {
360  // Otherwise: if the input and output events are not the same,
361  // just copy the bank whole.
362  if(input_event != output_event) {
363  char *output_data;
364  bk_create(output_event, input_bank->name, input_bank->type,
365  &output_data);
366  memcpy(output_data, input_data, input_size);
367  bk_close(output_event, output_data + input_size);
368  }
369  }
370  }
371 }
int read_midas_event ( FILE *  fp,
char *  pevent 
)

Definition at line 24 of file overall.cpp.

References data_size, le32_to_cpu, and SUCCESS.

Referenced by main().

25 {
26 
27  int event_size, size_read;
28 
29  size_read = fread(pevent, 1, sizeof(EVENT_HEADER), fp);
30  if (size_read != sizeof(EVENT_HEADER))
31  return !SUCCESS;
32 
33  event_size = le32_to_cpu(((EVENT_HEADER *) pevent)->data_size);
34 
35  size_read = fread(pevent + sizeof(EVENT_HEADER), 1, event_size, fp);
36  if (size_read != event_size)
37  return !SUCCESS;
38 
39  bk_swap(pevent, 0);
40 
41  return SUCCESS;
42 }

Variable Documentation

int verbose = 0
static

Definition at line 21 of file overall.cpp.

Referenced by compress_bank().

Generated by   doxygen 1.8.4