Belle II Software development
PreRawCOPPERFormat_v1.cc
1/**************************************************************************
2 * basf2 (Belle II Analysis Software Framework) *
3 * Author: The Belle II Collaboration *
4 * *
5 * See git log for contributors and copyright holders. *
6 * This file is licensed under LGPL-3.0, see LICENSE.md. *
7 **************************************************************************/
8
9#include <rawdata/dataobjects/PreRawCOPPERFormat_v1.h>
10
11
12using namespace std;
13using namespace Belle2;
14
15//#define DESY
16//#define NO_DATA_CHECK
17//#define WO_FIRST_EVENUM_CHECK
18
19//ClassImp(PreRawCOPPERFormat_v1);
20
21PreRawCOPPERFormat_v1::PreRawCOPPERFormat_v1()
22{
23}
24
25PreRawCOPPERFormat_v1::~PreRawCOPPERFormat_v1()
26{
27}
28
29
30// int PreRawCOPPERFormat_v1::GetBufferPos(int n)
31// {
32// if (m_buffer == NULL || m_nwords <= 0) {
33// char err_buf[500];
34// sprintf(err_buf, "[DEBUG] [ERROR] RawPacket buffer(%p) is not available or length(%d) is not set.\n %s %s %d\n",
35// m_buffer, m_nwords, __FILE__, __PRETTY_FUNCTION__, __LINE__);
36// printf("%s", err_buf); fflush(stdout);
37// string err_str = err_buf; throw (err_str);
38// }
39
40// if (n >= (m_num_events * m_num_nodes)) {
41// char err_buf[500];
42// sprintf(err_buf, "[DEBUG] Invalid COPPER block No. (%d : max %d ) is specified. Exiting... \n %s %s %d\n",
43// n, (m_num_events * m_num_nodes), __FILE__, __PRETTY_FUNCTION__, __LINE__);
44// printf("%s", err_buf); fflush(stdout);
45// string err_str = err_buf; throw (err_str);
46
47// }
48// int pos_nwords = 0;
49// for (int i = 1; i <= n ; i++) {
50// int size = tmp_header.RAWHEADER_NWORDS
51// + m_buffer[ pos_nwords + tmp_header.RAWHEADER_NWORDS + POS_DATA_LENGTH ]
52// + SIZE_COPPER_DRIVER_HEADER
53// + SIZE_COPPER_DRIVER_TRAILER
54// + tmp_trailer.RAWTRAILER_NWORDS;
55// // COPPER's data length include one word from COPPER trailer. so -1 is needed.
56// pos_nwords += size;
57// if (pos_nwords >= m_nwords) {
58// char err_buf[500];
59
60// sprintf(err_buf, "CORRUPTED DATA: value of pos_nwords(%d) is larger than m_nwords(%d). Exiting...\n %s %s %d\n",
61// pos_nwords, m_nwords, __FILE__, __PRETTY_FUNCTION__, __LINE__);
62// printf("%s", err_buf); fflush(stdout);
63// string err_str = err_buf; throw (err_str);
64// // exit(1);
65// }
66// }
67// return pos_nwords;
68// }
69
70
71
72unsigned int PreRawCOPPERFormat_v1::CalcDriverChkSum(int n)
73{
74 int min = GetBufferPos(n) + tmp_header.RAWHEADER_NWORDS;
75 int max = GetBufferPos(n) + GetBlockNwords(n)
76 - tmp_trailer.RAWTRAILER_NWORDS - SIZE_COPPER_DRIVER_TRAILER;
77 unsigned int chksum = 0;
78 for (int i = min; i < max; i++) {
79 chksum ^= m_buffer[ i ];
80 }
81 return chksum;
82}
83
84
85
86int PreRawCOPPERFormat_v1::GetDetectorNwords(int n, int finesse_num)
87{
88
89 int nwords = 0;
90 if (GetFINESSENwords(n, finesse_num) > 0) {
91 nwords = GetFINESSENwords(n, finesse_num)
92 - (static_cast<int>(SIZE_B2LHSLB_HEADER) + SIZE_B2LHSLB_TRAILER + SIZE_B2LFEE_HEADER + SIZE_B2LFEE_TRAILER);
93 }
94 return nwords;
95
96}
97
98
99int PreRawCOPPERFormat_v1::GetFINESSENwords(int n, int finesse_num)
100{
101 if (!CheckCOPPERMagic(n)) {
102 char err_buf[500];
103 PrintData(m_buffer, m_nwords);
104 sprintf(err_buf,
105 "[ERROR] COPPER's magic word is invalid. Exiting... Maybe it is due to data corruption or different version of the data format.\n %s %s %d\n",
106 __FILE__, __PRETTY_FUNCTION__, __LINE__);
107 printf("%s", err_buf); fflush(stdout);
108 B2FATAL(err_buf);
109 }
110 int pos_nwords;
111 switch (finesse_num) {
112 case 0 :
113 pos_nwords = GetBufferPos(n) + tmp_header.RAWHEADER_NWORDS + POS_CH_A_DATA_LENGTH;
114 break;
115 case 1 :
116 pos_nwords = GetBufferPos(n) + tmp_header.RAWHEADER_NWORDS + POS_CH_B_DATA_LENGTH;
117 break;
118 case 2 :
119 pos_nwords = GetBufferPos(n) + tmp_header.RAWHEADER_NWORDS + POS_CH_C_DATA_LENGTH;
120 break;
121 case 3 :
122 pos_nwords = GetBufferPos(n) + tmp_header.RAWHEADER_NWORDS + POS_CH_D_DATA_LENGTH;
123 break;
124 default :
125 char err_buf[500];
126 sprintf(err_buf, "Specifined FINESSE number( = %d ) is invalid. Exiting...\n %s %s %d\n",
127 finesse_num, __FILE__, __PRETTY_FUNCTION__, __LINE__);
128 printf("%s", err_buf); fflush(stdout);
129 B2FATAL(err_buf);
130 }
131 return m_buffer[ pos_nwords ];
132
133}
134
135
136unsigned int PreRawCOPPERFormat_v1::GetB2LFEE32bitEventNumber(int n)
137{
138
139#ifndef READ_OLD_B2LFEE_FORMAT_FILE
140
141 int err_flag = 0;
142 unsigned int eve_num = 0;
143 int flag = 0;
144 unsigned int eve[4];
145 for (int i = 0; i < 4 ; i++) {
146 eve[ i ] = 12345678;
147 if (GetFINESSENwords(n, i) > 0) {
148 int pos_nwords = GetOffsetFINESSE(n, i) + SIZE_B2LHSLB_HEADER + POS_TT_TAG;
149 eve[ i ] = m_buffer[ pos_nwords ];
150 if (flag != 1) eve_num = eve[ i ];
151 if (eve_num != eve[ i ]) err_flag = 1;
152 flag = 1;
153 }
154 }
155
156 if (flag == 0) {
157 PrintData(m_buffer, m_nwords);
158 char err_buf[500];
159 sprintf(err_buf, "No HSLB data in COPPER data. Exiting...\n%s %s %d\n",
160 __FILE__, __PRETTY_FUNCTION__, __LINE__);
161 printf("%s", err_buf); fflush(stdout);
162 B2FATAL(err_buf);
163 }
164
165 if (err_flag == 1) {
166 PrintData(m_buffer, m_nwords);
167 char err_buf[500];
168 sprintf(err_buf, "CORRUPTED DATA: Different event number over HSLBs : slot A 0x%x : B 0x%x :C 0x%x : D 0x%x\n%s %s %d\n",
169 eve[ 0 ], eve[ 1 ], eve[ 2 ], eve[ 3 ],
170 __FILE__, __PRETTY_FUNCTION__, __LINE__);
171 printf("[DEBUG] [ERROR] %s\n", err_buf); fflush(stdout);
172#ifndef NO_DATA_CHECK
173 B2FATAL(err_buf);
174#endif //NO_DATA_CHECK
175 }
176 return eve_num;
177
178#else // READ_OLD_B2LFEE_FORMAT_FILE
179
180 char err_buf[500];
181 sprintf(err_buf, "You need comment out READ_OLD_B2LFEE_FORMAT_FILE if you are handling a new data format\n%s %s %d\n",
182 __FILE__, __PRETTY_FUNCTION__, __LINE__);
183 printf("%s", err_buf); fflush(stdout);
184 B2FATAL(err_buf);
185
186#endif // READ_OLD_B2LFEE_FORMAT_FILE
187
188}
189
190
191void PreRawCOPPERFormat_v1::CheckData(int n,
192 unsigned int prev_evenum, unsigned int* cur_evenum_rawcprhdr,
193 unsigned int prev_copper_ctr, unsigned int* cur_copper_ctr,
194 unsigned int prev_exprunsubrun_no, unsigned int* cur_exprunsubrun_no)
195{
196
197 char err_buf[500];
198 sprintf(err_buf,
199 "This function for format ver.1 is not supported. (n %d preveve %u eve %u prectr %u ctr %u prevrun %u run %u) Exiting...\n %s %s %d\n",
200 n, prev_evenum, *cur_evenum_rawcprhdr, prev_copper_ctr, *cur_copper_ctr,
201 prev_exprunsubrun_no, *cur_exprunsubrun_no,
202 __FILE__, __PRETTY_FUNCTION__, __LINE__);
203 printf("%s", err_buf); fflush(stdout);
204 B2FATAL(err_buf);
205
206// char err_buf[500];
207// int err_flag = 0;
208// //
209// // check Magic words
210// //
211// if (!CheckCOPPERMagic(n)) {
212// sprintf(err_buf, "CORRUPTED DATA: Invalid Magic word 0x7FFFF0008=%u 0xFFFFFAFA=%u 0xFFFFF5F5=%u 0x7FFF0009=%u\n%s %s %d\n",
213// GetMagicDriverHeader(n),
214// GetMagicFPGAHeader(n),
215// GetMagicFPGATrailer(n),
216// GetMagicDriverTrailer(n),
217// __FILE__, __PRETTY_FUNCTION__, __LINE__);
218// err_flag = 1;
219// }
220
221// //
222// // Event # check
223// //
224// *cur_evenum_rawcprhdr = GetEveNo(n);
225// unsigned int evenum_feehdr = GetB2LFEE32bitEventNumber(n);
226// if (*cur_evenum_rawcprhdr != evenum_feehdr) {
227// sprintf(err_buf,
228// "CORRUPTED DATA: Event # in PreRawCOPPERFormat_v1 header and FEE header is different : cprhdr 0x%x feehdr 0x%x : Exiting...\n%s %s %d\n",
229// *cur_evenum_rawcprhdr, evenum_feehdr,
230// __FILE__, __PRETTY_FUNCTION__, __LINE__);
231// err_flag = 1;
232// }
233
234// //
235// // Check incrementation of event #
236// //
237// *cur_runsubrun_no = GetRunNoSubRunNo(n);
238// if (
239// #ifdef WO_FIRST_EVENUM_CHECK
240// prev_evenum != 0xFFFFFFFF && *cur_evenum_rawcprhdr != 0
241// #else
242// prev_runsubrun_no == *cur_runsubrun_no && prev_runsubrun_no >= 0
243// #endif
244// ) {
245// if ((unsigned int)(prev_evenum + 1) != *cur_evenum_rawcprhdr) {
246// sprintf(err_buf, "CORRUPTED DATA: Event # jump : i %d prev 0x%x cur 0x%x : Exiting...\n%s %s %d\n",
247// n, prev_evenum, *cur_evenum_rawcprhdr,
248// __FILE__, __PRETTY_FUNCTION__, __LINE__);
249// err_flag = 1;
250// }
251// }
252
253
254// *cur_copper_ctr = GetCOPPERCounter(n);
255// if (
256// #ifdef WO_FIRST_EVENUM_CHECK
257// prev_copper_ctr != 0xFFFFFFFF
258// #else
259// true
260// #endif
261// ) {
262// if ((unsigned int)(prev_copper_ctr + 1) != *cur_copper_ctr) {
263// sprintf(err_buf, "COPPER counter jump : i %d prev 0x%x cur 0x%x :\n%s %s %d\n",
264// n, prev_copper_ctr, *cur_copper_ctr,
265// __FILE__, __PRETTY_FUNCTION__, __LINE__);
266
267// #ifdef DESY
268// //
269// // In DESY test, we ignore this error
270// //
271// printf("[DEBUG] [INFO] %s", err_buf);
272// #else
273// err_flag = 1;
274// #endif
275
276// }
277// }
278
279// //
280// // Check is utime and ctime_trgtype same over different FINESSE data
281// //
282// CheckUtimeCtimeTRGType(n);
283
284
285// //
286// // Check checksum calculated by COPPER driver
287// //
288// if (GetDriverChkSum(n) != CalcDriverChkSum(n)) {
289// sprintf(err_buf,
290// "CORRUPTED DATA: COPPER driver checkSum error : block %d : length %d eve 0x%x : Trailer chksum 0x%.8x : calcd. now 0x%.8x\n%s %s %d\n",
291// n,
292// GetBlockNwords(n),
293// *cur_evenum_rawcprhdr,
294// GetDriverChkSum(n),
295// CalcDriverChkSum(n),
296// __FILE__, __PRETTY_FUNCTION__, __LINE__);
297// err_flag = 1;
298// }
299
300
301// //
302// // Check checksum calculated by DeSerializerCOPPER()
303// //
304// tmp_trailer.SetBuffer(GetRawTrlBufPtr(n));
305// unsigned int xor_chksum = CalcXORChecksum(GetBuffer(n), GetBlockNwords(n) - tmp_trailer.GetTrlNwords());
306// if (tmp_trailer.GetChksum() != xor_chksum) {
307// sprintf(err_buf,
308// "CORRUPTED DATA: PreRawCOPPERFormat_v1 checksum error : block %d : length %d eve 0x%x : Trailer chksum 0x%.8x : calcd. now 0x%.8x\n %s %s %d\n",
309// n, GetBlockNwords(n), *cur_evenum_rawcprhdr, tmp_trailer.GetChksum(), xor_chksum,
310// __FILE__, __PRETTY_FUNCTION__, __LINE__);
311// err_flag = 1;
312// }
313
314
315// #ifdef DEBUG
316// printf("[DEBUG] eve %d %d %d %d %d\n",
317// GetEveNo(n),
318// Get1stDetectorNwords(n),
319// Get2ndDetectorNwords(n),
320// Get3rdDetectorNwords(n),
321// Get4thDetectorNwords(n)
322// );
323// printf("[DEBUG] ===COPPER BLOCK==============\n");
324// printData(GetBuffer(n), GetBlockNwords(n));
325
326// printf("[DEBUG] ===FINNESSE A ==============\n");
327// printData(Get1stDetectorBuffer(n), Get1stDetectorNwords(n));
328
329// printf("[DEBUG] ===FINNESSE B ==============\n");
330// printData(Get2ndDetectorBuffer(n), Get2ndDetectorNwords(n));
331
332// printf("[DEBUG] ===FINNESSE C ==============\n");
333// printData(Get3rdDetectorBuffer(n), Get3rdDetectorNwords(n));
334
335// printf("[DEBUG] ===FINNESSE D ==============\n");
336// printData(Get4thDetectorBuffer(n), Get4thDetectorNwords(n));
337// printf("[DEBUG] === END ==============\n");
338
339// #endif
340
341// if (err_flag == 1) {
342// printf("[DEBUG] ========== dump a data blcok : block # %d==========\n", n);
343// PrintData(GetBuffer(n), GetBlockNwords(n));
344// printf("%s", err_buf); fflush(stdout);
345// string err_str = err_buf;
346// throw (err_str);
347
348// // sleep(1234567);
349// // exit(-1);
350// }
351
352 return;
353
354}
355
356bool PreRawCOPPERFormat_v1::CheckCOPPERMagic(int n)
357{
358 if (GetMagicDriverHeader(n) != COPPER_MAGIC_DRIVER_HEADER) {
359 return false;
360 } else if (GetMagicFPGAHeader(n) != COPPER_MAGIC_FPGA_HEADER) {
361 return false;
362 } else if (GetMagicFPGATrailer(n) != COPPER_MAGIC_FPGA_TRAILER) {
363 return false;
364 } else if (GetMagicDriverTrailer(n) != COPPER_MAGIC_DRIVER_TRAILER) {
365 return false;
366 }
367 return true;
368}
369
370void PreRawCOPPERFormat_v1::CheckUtimeCtimeTRGType(int n)
371{
372
373#ifdef USE_B2LFEE_FORMAT_BOTH_VER1_AND_2
374 CheckB2LFEEHeaderVersion(n);
375#endif
376 int err_flag = 0;
377 int flag = 0;
378 unsigned int temp_utime = 0, temp_ctime_trgtype = 0;
379 unsigned int utime[4], ctime_trgtype[4];
380 memset(utime, 0, sizeof(utime));
381 memset(ctime_trgtype, 0, sizeof(ctime_trgtype));
382
383 for (int i = 0; i < 4; i++) {
384 if (GetFINESSENwords(n, i) > 0) {
385 ctime_trgtype[ i ] = m_buffer[ GetOffsetFINESSE(n, i) +
386 SIZE_B2LHSLB_HEADER + POS_TT_CTIME_TYPE ];
387 utime[ i ] = m_buffer[ GetOffsetFINESSE(n, i) +
388 SIZE_B2LHSLB_HEADER + POS_TT_UTIME ];
389 if (flag == 0) {
390 temp_ctime_trgtype = ctime_trgtype[ i ];
391 temp_utime = utime[ i ];
392 flag = 1;
393 } else {
394 if (temp_ctime_trgtype != ctime_trgtype[ i ]
395 || temp_utime != utime[ i ]) {
396 err_flag = 1;
397 }
398 }
399 }
400 }
401
402 if (err_flag != 0) {
403 for (int i = 0; i < 4; i++) {
404 printf("[DEBUG] FINESSE #=%d buffsize %d ctimeTRGtype 0x%.8x utime 0x%.8x\n",
405 i, GetFINESSENwords(n, i), ctime_trgtype[ i ], utime[ i ]);
406 }
407 char err_buf[500];
408 sprintf(err_buf, "CORRUPTED DATA: mismatch over FINESSEs. Exiting...\n %s %s %d\n",
409 __FILE__, __PRETTY_FUNCTION__, __LINE__);
410 printf("%s", err_buf); fflush(stdout);
411 B2FATAL(err_buf);
412 }
413 return;
414}
415
416
417unsigned int PreRawCOPPERFormat_v1::FillTopBlockRawHeader(unsigned int m_node_id, unsigned int prev_eve32,
418 unsigned int prev_exprunsubrun_no, unsigned int* cur_exprunsubrun_no)
419{
420
421 char err_buf[500];
422 sprintf(err_buf,
423 "This function for format ver.1 is not supported. (node %.8x preveve %u prevrun %u currun %u ) Exiting...\n %s %s %d\n",
424 m_node_id, prev_eve32, prev_exprunsubrun_no, *cur_exprunsubrun_no,
425 __FILE__, __PRETTY_FUNCTION__, __LINE__);
426 printf("%s", err_buf); fflush(stdout);
427 B2FATAL(err_buf);
428
429 return 0xffffffff;
430
431// const int datablock_id = 0;
432// // m_temp_value = 12345678;
433// //
434// // This function only fills RawHeader contents for the first datablock.
435// // # of block should be 1
436// if (m_num_nodes * m_num_events != 1) {
437// char err_buf[500];
438// sprintf(err_buf,
439// "This function should be used for PreRawCOPPERFormat_v1 containing only one datablock, while. this object has num_nodes of %d and num_events of %d\n %s %s %d\n",
440// m_num_nodes, m_num_events, __FILE__, __PRETTY_FUNCTION__, __LINE__);
441// printf("%s", err_buf); fflush(stdout);
442// string err_str = err_buf; throw (err_str);
443
444// }
445
446// //////////////////////////////////////////////////
447// //
448// // Fill info in RawHeader
449// //
450// //////////////////////////////////////////////////
451
452// //
453// // Initialize a RawHeader part
454// //
455// memset(m_buffer, 0, sizeof(int) * tmp_header.RAWHEADER_NWORDS);
456// m_buffer[ tmp_header.POS_VERSION_HDRNWORDS ] = tmp_header.RAWHEADER_NWORDS & tmp_header.HDR_NWORDS_MASK;
457// m_buffer[ tmp_header.POS_VERSION_HDRNWORDS ] |= (DATA_FORMAT_VERSION << tmp_header.FORMAT_VERSION_SHIFT) &
458// tmp_header.FORMAT_VERSION__MASK;
459// m_buffer[ tmp_header.POS_VERSION_HDRNWORDS ] |= (0x80 << tmp_header.FORMAT_VERSION_SHIFT); // PreFormat
460// m_buffer[ tmp_header.POS_VERSION_HDRNWORDS ] |= tmp_header.MAGIC_WORD;
461
462// //
463// // Check FINESSEs which containes data
464// //
465// int* copper_buf = &(m_buffer[ tmp_header.RAWHEADER_NWORDS ]);
466// if (copper_buf[ POS_CH_A_DATA_LENGTH ] == 0 &&
467// copper_buf[ POS_CH_B_DATA_LENGTH ] == 0 &&
468// copper_buf[ POS_CH_C_DATA_LENGTH ] == 0 &&
469// copper_buf[ POS_CH_D_DATA_LENGTH ] == 0) {
470// char err_buf[500];
471// sprintf(err_buf,
472// "No FINESSE data in a copper data block. Exiting...\n %s %s %d\n",
473// __FILE__, __PRETTY_FUNCTION__, __LINE__);
474// printf("%s", err_buf); fflush(stdout);
475// string err_str = err_buf; throw (err_str);
476// // sleep(12345678);
477// // exit(-1);
478// }
479
480// //
481// // Set total words info
482// //
483// int datablock_nwords =
484// tmp_header.RAWHEADER_NWORDS +
485// (copper_buf[ POS_DATA_LENGTH ]
486// + SIZE_COPPER_DRIVER_HEADER
487// + SIZE_COPPER_DRIVER_TRAILER)
488// + tmp_trailer.RAWTRAILER_NWORDS;
489// m_buffer[ tmp_header.POS_NWORDS ] = datablock_nwords;
490
491
492// //
493// // Check the consistency between data length and length in RawHeader
494// //
495// if (m_buffer[ tmp_header.POS_NWORDS ] != m_nwords) {
496// char err_buf[500];
497// sprintf(err_buf,
498// "CORRUPTED DATA: Data length is inconsistent m_nwords %d : nwords from COPPER data %d\n %s %s %d\n",
499// m_nwords, m_buffer[ tmp_header.POS_NWORDS ],
500// __FILE__, __PRETTY_FUNCTION__, __LINE__);
501// printf("%s", err_buf); fflush(stdout);
502// string err_str = err_buf; throw (err_str);
503// // sleep(12345678);
504// // exit(-1);
505// }
506
507// //
508// // Fill offset values
509// //
510// int offset_1st_finesse = tmp_header.RAWHEADER_NWORDS + SIZE_COPPER_HEADER;
511// int offset_2nd_finesse = offset_1st_finesse + copper_buf[ POS_CH_A_DATA_LENGTH ];
512// int offset_3rd_finesse = offset_2nd_finesse + copper_buf[ POS_CH_B_DATA_LENGTH ];
513// int offset_4th_finesse = offset_3rd_finesse + copper_buf[ POS_CH_C_DATA_LENGTH ];
514// m_buffer[ tmp_header.POS_OFFSET_1ST_FINESSE ] = offset_1st_finesse;
515// m_buffer[ tmp_header.POS_OFFSET_2ND_FINESSE ] = offset_2nd_finesse;
516// m_buffer[ tmp_header.POS_OFFSET_3RD_FINESSE ] = offset_3rd_finesse;
517// m_buffer[ tmp_header.POS_OFFSET_4TH_FINESSE ] = offset_4th_finesse;
518
519// //
520// // Fill Exp/Run value
521// //
522// int* finesse_buf = &
523// (m_buffer[ offset_1st_finesse ]); // In any finesse implementations, the top finesse buffer should be at offset_1st_finesse;
524// m_buffer[ tmp_header.POS_EXP_RUN_NO ] = finesse_buf[ SIZE_B2LHSLB_HEADER + POS_EXP_RUN ];
525
526
527// //
528// // Fill event #
529// //
530// unsigned int cur_ftsw_eve32 = finesse_buf[ SIZE_B2LHSLB_HEADER + POS_TT_TAG ];
531// m_buffer[ tmp_header.POS_EVE_NO ] = cur_ftsw_eve32;
532
533// //
534// // Copy FTSW words from B2LFEE header
535// //
536// m_buffer[ tmp_header.POS_TTCTIME_TRGTYPE ] = finesse_buf[ SIZE_B2LHSLB_HEADER + POS_TT_CTIME_TYPE ];
537// m_buffer[ tmp_header.POS_TTUTIME ] = finesse_buf[ SIZE_B2LHSLB_HEADER + POS_TT_UTIME ];
538
539// //
540// // Set node ID, trunc_mask, data_type
541// //
542// m_buffer[ tmp_header.POS_NODE_ID ] = m_node_id;
543// m_buffer[ tmp_header.POS_TRUNC_MASK_DATATYPE ] = ((m_trunc_mask << 31) & 0x80000000) | (m_data_type & 0x7FFFFFFF);
544
545
546// //////////////////////////////////////////////////
547// //
548// // Fill info in RawTrailer
549// //
550// //////////////////////////////////////////////////
551
552// //
553// // Calculate XOR checksum
554// //
555// unsigned int chksum_top = 0, chksum_body = 0, chksum_bottom = 0;
556
557// int top_end = tmp_header.RAWHEADER_NWORDS;
558// for (int i = 0; i < top_end; i++) {
559// chksum_top ^= m_buffer[ i ];
560// }
561// int body_end = datablock_nwords - SIZE_COPPER_DRIVER_TRAILER - tmp_trailer.RAWTRAILER_NWORDS;
562// for (int i = top_end; i < body_end; i++) {
563// chksum_body ^= m_buffer[ i ];
564// }
565
566// int bottom_end = datablock_nwords - tmp_trailer.RAWTRAILER_NWORDS;
567// for (int i = body_end; i < bottom_end; i++) {
568// chksum_bottom ^= m_buffer[ i ];
569// }
570
571// //
572// // check COPPER driver checksum
573// //
574// if (chksum_body != (unsigned int)(m_buffer[ body_end ])) {
575// char err_buf[500];
576// sprintf(err_buf, "CORRUPTED DATA: COPPER driver checksum is not consistent.: calcd. %.8x data %.8x\n %s %s %d\n",
577// chksum_body, m_buffer[ body_end ],
578// __FILE__, __PRETTY_FUNCTION__, __LINE__);
579// printf("%s", err_buf); fflush(stdout);
580// string err_str = err_buf; throw (err_str);
581// // sleep(12345678);
582// // exit(-1);
583// }
584
585// //
586// // Fill trailer info (checksum, magic word)
587// //
588// unsigned int chksum = chksum_top ^ chksum_body ^ chksum_bottom;
589// int* trl = &(m_buffer[ datablock_nwords - tmp_trailer.RAWTRAILER_NWORDS ]);
590// trl[ tmp_trailer.POS_CHKSUM ] = chksum;
591// trl[ tmp_trailer.POS_TERM_WORD ] = tmp_trailer.MAGIC_WORD_TERM_TRAILER;
592
593
594// //////////////////////////////////////////////////
595// //
596// // Data check ( magic word, event incrementation )
597// //
598// //////////////////////////////////////////////////
599
600
601// //
602// // check magic words
603// //
604// int* fpga_trailer_magic = trl - (SIZE_COPPER_TRAILER - POS_MAGIC_COPPER_3);
605// int* driver_trailer_magic = trl - (SIZE_COPPER_TRAILER - POS_MAGIC_COPPER_4);
606// int err_flag = 0;
607// if ((unsigned int)(copper_buf[ POS_MAGIC_COPPER_1 ]) != COPPER_MAGIC_DRIVER_HEADER) {
608// err_flag = 1;
609// } else if ((unsigned int)(copper_buf[ POS_MAGIC_COPPER_2 ]) != COPPER_MAGIC_FPGA_HEADER) {
610// err_flag = 1;
611// } else if ((unsigned int)(*fpga_trailer_magic) != COPPER_MAGIC_FPGA_TRAILER) {
612// err_flag = 1;
613// } else if ((unsigned int)(*driver_trailer_magic) != COPPER_MAGIC_DRIVER_TRAILER) {
614// err_flag = 1;
615// }
616// if (err_flag == 1) {
617// char err_buf[500];
618// sprintf(err_buf, "CORRUPTED DATA: Invalid Magic word 0x7FFFF0008=%u 0xFFFFFAFA=%u 0xFFFFF5F5=%u 0x7FFF0009=%u\n %s %s %d\n",
619// GetMagicDriverHeader(datablock_id),
620// GetMagicFPGAHeader(datablock_id),
621// GetMagicFPGATrailer(datablock_id),
622// GetMagicDriverTrailer(datablock_id),
623// __FILE__, __PRETTY_FUNCTION__, __LINE__);
624// printf("[DEBUG] [ERROR] %s\n", err_buf);
625// #ifndef NO_DATA_CHECK
626// string err_str = err_buf; throw (err_str);
627
628// // sleep(12345678);
629// // exit(-1);
630// #endif
631// }
632
633// //
634// // check incrementation of event #
635// //
636
637// if ((unsigned int)(prev_eve32 + 1) < 50) {
638// // printf("#################EVE cur %.8x prev %.8x\n", cur_ftsw_eve32, prev_eve32);
639// // fflush(stdout);
640// }
641
642
643// *cur_runsubrun_no = GetRunNoSubRunNo(datablock_id);
644// if (prev_runsubrun_no == *cur_runsubrun_no && prev_runsubrun_no >= 0) {
645// if (
646// #ifdef WO_FIRST_EVENUM_CHECK
647// (prev_eve32 + 1 != cur_ftsw_eve32) && (prev_eve32 != 0xFFFFFFFF && cur_ftsw_eve32 != 0)
648// #else
649// prev_eve32 + 1 != cur_ftsw_eve32
650// #endif
651// ) {
652// #ifndef NO_DATA_CHECK
653// char err_buf[500];
654// sprintf(err_buf, "CORRUPTED DATA: Invalid event_number. Exiting...: cur 32bit eve %u preveve %u prun %d crun %d\n %s %s %d\n",
655// cur_ftsw_eve32, prev_eve32,
656// prev_runsubrun_no, *cur_runsubrun_no,
657// __FILE__, __PRETTY_FUNCTION__, __LINE__);
658// printf("[DEBUG] [ERROR] %s\n", err_buf);
659
660// string err_str = err_buf;
661// printf("[DEBUG] i= %d : num entries %d : Tot words %d\n", 0 , GetNumEntries(), TotalBufNwords());
662// PrintData(GetBuffer(datablock_id), TotalBufNwords());
663
664// throw (err_str);
665// // exit(-1);
666// #endif
667
668// }
669// }
670
671// return cur_ftsw_eve32;
672
673}
674
675
676
677#ifdef USE_B2LFEE_FORMAT_BOTH_VER1_AND_2
678void PreRawCOPPERFormat_v1::CheckB2LFEEHeaderVersion(int n)
679{
680 int* temp_buf;
681 for (int i = 0; i < 4; i++) {
682 if (GetFINESSENwords(n, i) > 0) {
683 temp_buf = GetFINESSEBuffer(n, i);
684 if ((temp_buf[ 3 ] & 0x40000000) == 0) {
685#ifdef TEMP
686 // this word for exp/run
687 // old one (ver.1) used for SPring8 test in 2013
688 printf("[DEBUG] \033[31m");
689 printf("[DEBUG] ===Firmware ver. ERROR===\n ");
690 printf("[DEBUG] FTSW and b2tt firmwares was updated on Nov.22, 2013 and the header format attached by B2link was changed in the new firmwares.\n");
691 printf("[DEBUG] If you are going to take data now, Please update the firmware.\n");
692 printf("[DEBUG] For details, please see Nakao-san's e-mail [b2link_ml:0111] Re: [daq2ml:0159] beta version of trigger timing receiver firmware (b2tt) on bdaq SVN\n");
693 printf("[DEBUG] Or if you are going to read data taken before the update, please use basf2 software before svn rev. 7419\n");
694 printf("[DEBUG] About the format please see Nakao-san's B2GM slides(p. 13 and 15) http://kds.kek.jp/getFile.py/access?contribId=143&sessionId=38&resId=0&materialId=slides&confId=13911.\n");
695 printf("[DEBUG] Sorry for inconvenience.\n");
696 printf("[DEBUG] \033[0m");
697 fflush(stderr);
698 char err_buf[500];
699 sprintf(err_buf, "FTSW and b2tt firmwares are old. Exiting...\n %s %s %d\n",
700 __FILE__, __PRETTY_FUNCTION__, __LINE__);
701 printf("%s", err_buf); fflush(stdout);
702 B2FATAL(err_buf);
703#endif
704 } else {
705 // this word for 32bit unixtime
706 // new one (ver.2)
707 break;
708 }
709 }
710
711 if (i == 3) {
712#ifdef TEMP
713 char err_buf[500];
714 sprintf(err_buf, "PreRawCOPPERFormat_v1 contains no FINESSE data. Exiting...\n %s %s %d\n",
715 __FILE__, __PRETTY_FUNCTION__, __LINE__);
716 printf("%s", err_buf); fflush(stdout);
717 B2FATAL(err_buf);
718#endif
719 }
720 }
721 return;
722}
723#endif
724
725
726//int PreRawCOPPERFormat_v1::CalcReducedDataSize(RawDataBlock* raw_datablk)
727int PreRawCOPPERFormat_v1::CalcReducedDataSize(int* bufin, int nwords, int num_events, int num_nodes)
728{
729 //
730 // Calculate reduced length for a total RawDataBlock (containing multiple data blocks)
731 //
732 PreRawCOPPERFormat_v1 rawcpr_fmt;
733 int delete_flag = 0;
734 rawcpr_fmt.SetBuffer(bufin, nwords, delete_flag, num_events, num_nodes);
735
736 int reduced_nwords = 0;
737 for (int k = 0; k < rawcpr_fmt.GetNumEvents(); k++) {
738 int num_nodes_in_sendblock = rawcpr_fmt.GetNumNodes();
739 for (int l = 0; l < num_nodes_in_sendblock; l++) {
740 int entry_id = l + k * num_nodes_in_sendblock;
741 if (rawcpr_fmt.CheckFTSWID(entry_id) || rawcpr_fmt.CheckTLUID(entry_id)) {
742 // No size reduction for non-COPPER data ( FTSW and TLU data blocks )
743 reduced_nwords += rawcpr_fmt.GetBlockNwords(entry_id);
744 } else {
745 PreRawCOPPERFormat_v1 temp_prerawcpr;
746 int temp_delete_flag = 0, temp_num_eve = 1, temp_num_nodes = 1;
747
748 // Call CalcReducedNwords
749 temp_prerawcpr.SetBuffer(rawcpr_fmt.GetBuffer(entry_id),
750 rawcpr_fmt.GetBlockNwords(entry_id),
751 temp_delete_flag, temp_num_eve,
752 temp_num_nodes);
753 reduced_nwords += temp_prerawcpr.CalcReducedNwords(0);
754 }
755 }
756 }
757 return reduced_nwords;
758
759}
760
761//void PreRawCOPPERFormat_v1::CopyReducedData(RawDataBlock* raw_datablk, int* buf_to, int delete_flag_from)
762void PreRawCOPPERFormat_v1::CopyReducedData(int* bufin, int nwords, int num_events, int num_nodes, int* buf_to, int* nwords_to)
763{
764 //
765 // Make a reduced buffer a total RawDataBlock (containing multiple data blocks)
766 //
767 PreRawCOPPERFormat_v1 rawcpr_fmt;
768 int delete_flag = 0;
769 rawcpr_fmt.SetBuffer(bufin, nwords, delete_flag, num_events, num_nodes);
770
771 int pos_nwords_to = 0;
772 for (int k = 0; k < rawcpr_fmt.GetNumEvents(); k++) {
773 int num_nodes_in_sendblock = rawcpr_fmt.GetNumNodes();
774 for (int l = 0; l < num_nodes_in_sendblock; l++) {
775 int entry_id = l + k * num_nodes_in_sendblock;
776 if (rawcpr_fmt.CheckFTSWID(entry_id) ||
777 rawcpr_fmt.CheckTLUID(entry_id)) {
778 rawcpr_fmt.CopyBlock(entry_id, buf_to + pos_nwords_to);
779 pos_nwords_to += rawcpr_fmt.GetBlockNwords(entry_id);
780
781 } else {
782 SetBuffer(rawcpr_fmt.GetBuffer(entry_id),
783 rawcpr_fmt.GetBlockNwords(entry_id), 0, 1, 1);
784
785 pos_nwords_to += CopyReducedBuffer(0, buf_to + pos_nwords_to);
786
787
788 }
789 }
790 }
791
792// int* buf_from = raw_datablk->GetWholeBuffer();
793// raw_datablk->SetBuffer(buf_to, pos_nwords_to, 0,
794// raw_datablk->GetNumEvents(), raw_datablk->GetNumNodes());
795// if (delete_flag_from == 1) { delete[] buf_from;}
796 *nwords_to = pos_nwords_to;
797 return ;
798}
799
800
801int PreRawCOPPERFormat_v1::CalcReducedNwords(int n)
802{
803 //
804 // Calculate reduced length for one data block which is a part of a RawDataBlock
805 //
806
807 int nwords_to = 0;
808
809 //RawCOPPER header
810 nwords_to += tmp_header.RAWHEADER_NWORDS;
811
812 for (int j = 0; j < 4; j++) {
813
814 int finesse_nwords = GetFINESSENwords(n, j);
815 if (finesse_nwords > 0) {
816 //
817 // B2L(HSLB/FEE) header and trailers are resized
818 // m_reduced_rawcpr should be PostRawCOPPERFormat_v1
819 //
820 nwords_to +=
821 finesse_nwords
822 - (static_cast<int>(SIZE_B2LHSLB_HEADER) - m_reduced_rawcpr.SIZE_B2LHSLB_HEADER)
823 - (static_cast<int>(SIZE_B2LFEE_HEADER) - m_reduced_rawcpr.SIZE_B2LFEE_HEADER)
824 - (static_cast<int>(SIZE_B2LFEE_TRAILER) - m_reduced_rawcpr.SIZE_B2LFEE_TRAILER)
825 - (static_cast<int>(SIZE_B2LHSLB_TRAILER) - m_reduced_rawcpr.SIZE_B2LHSLB_TRAILER);
826 }
827
828 }
829
830 //RawCOPPER Trailer
831 nwords_to += tmp_trailer.GetTrlNwords();
832
833 return nwords_to;
834}
835
836
837
838
839
840
841int PreRawCOPPERFormat_v1::CopyReducedBuffer(int n, int* buf_to)
842{
843 //
844 // Make a reduced buffer for one data block which is a part of a RawDataBlock
845 //
846
847 int* buf_from = NULL;
848 int nwords_buf_to = CalcReducedNwords(n);
849 int pos_nwords_to = 0;
850 int copy_nwords = 0;
851
852 // copyt to ReducedRawCOPPER
853 // ReducedRawCOPPER m_reduced_rawcpr;
854 //Header copy
855 copy_nwords = tmp_header.RAWHEADER_NWORDS;
856 buf_from = GetBuffer(n);
857 copyData(buf_to, &pos_nwords_to, buf_from, copy_nwords, nwords_buf_to);
858
859 // Unset the PreFormat bit ( 15th bit )
860 buf_to[ tmp_header.POS_VERSION_HDRNWORDS ] &= 0xFFFF7FFF;
861
862 //Check Header
863 // m_reduced_rawcpr.tmp_header.CheckHeader(buf_to + pos_nwords_to - copy_nwords);
864
865
866 // copy FINESSE buffer
867 int pos_nwords_finesse[ 4 ];
868 for (int j = 0; j < 4; j++) {
869 pos_nwords_finesse[ j ] = pos_nwords_to;
870 if (GetFINESSENwords(n, j) > 0) {
871 int* finesse_buf = GetFINESSEBuffer(n, j);
872 int finesse_nwords = GetFINESSENwords(n, j);
873
874
875 CheckB2LHSLBMagicWords(finesse_buf, finesse_nwords);
876 // copy the whole B2LHSLB header (1word)
877 buf_to[ pos_nwords_to ] = finesse_buf[ POS_MAGIC_B2LHSLB ];
878 pos_nwords_to++;
879
880 // copy the last word of B2LFEE and body( DetectorBuffer )
881 buf_from =
882 finesse_buf
883 + SIZE_B2LHSLB_HEADER
884 + POS_B2L_CTIME; //the last word of B2LFEE
885
886 // check finesse buffer size : ( When dumhslb was used, this type of error occured and RecvStream0.py died by Segmentation Fault. ) 2014.12.01.
887 if (finesse_nwords - SIZE_B2LHSLB_HEADER - SIZE_B2LFEE_HEADER
888 - SIZE_B2LFEE_TRAILER - SIZE_B2LHSLB_TRAILER < 0) {
889 char err_buf[500];
890 sprintf(err_buf,
891 "[ERROR] Finesse buffer size is too small( %d words < %d words). May be the data are corrupted. Exiting...\n %s %s %d\n",
892 finesse_nwords, static_cast<int>(SIZE_B2LHSLB_HEADER) + SIZE_B2LFEE_HEADER + SIZE_B2LFEE_TRAILER + SIZE_B2LHSLB_TRAILER,
893 __FILE__, __PRETTY_FUNCTION__, __LINE__);
894 printf("%s", err_buf); fflush(stdout);
895 B2FATAL(err_buf);
896 }
897
898 copy_nwords =
899 finesse_nwords
900 - SIZE_B2LHSLB_HEADER // already copied
901 - POS_B2L_CTIME // only one word copied ( SIZE_B2LFEE_HEADER - 1 = POS_B2L_CTIME )
902 - SIZE_B2LFEE_TRAILER // will be copied later
903 - SIZE_B2LHSLB_TRAILER; // Not copied
904
905 // printf("pos %d nwords %d nwords to %d\n", pos_nwords_to, copy_nwords, nwords_buf_to );
906 copyData(buf_to, &pos_nwords_to, buf_from, copy_nwords, nwords_buf_to);
907
908 //copy B2LFEE trailer(CRC info)
909 buf_to[ pos_nwords_to ] =
910 finesse_buf[ finesse_nwords - SIZE_B2LHSLB_TRAILER
911 - (SIZE_B2LFEE_TRAILER - POS_CHKSUM_B2LFEE) ];
912 pos_nwords_to++;
913
914 // check CRC data
915 // CheckCRC16( n, j );
916 }
917 }
918
919 // copy RawCOPPER trailer
920 buf_from =
921 GetBuffer(n)
922 + GetBlockNwords(n)
923 - tmp_trailer.GetTrlNwords();
924 copy_nwords = tmp_trailer.GetTrlNwords();
925 copyData(buf_to, &pos_nwords_to, buf_from, copy_nwords, nwords_buf_to);
926
927 // length check
928 if (pos_nwords_to != nwords_buf_to) {
929 char err_buf[500];
930 sprintf(err_buf, "Buffer overflow. Exiting... %d %d\n", pos_nwords_to, nwords_buf_to);
931 printf("%s", err_buf); fflush(stdout);
932 B2FATAL(err_buf);
933 }
934
935 //
936 // Apply changes followed by data size reduction
937 //
938 *(buf_to + m_reduced_rawcpr.tmp_header.POS_NWORDS) = nwords_buf_to;
939 *(buf_to + m_reduced_rawcpr.tmp_header.POS_OFFSET_1ST_FINESSE) = pos_nwords_finesse[ 0 ];
940 *(buf_to + m_reduced_rawcpr.tmp_header.POS_OFFSET_2ND_FINESSE) = pos_nwords_finesse[ 1 ];
941 *(buf_to + m_reduced_rawcpr.tmp_header.POS_OFFSET_3RD_FINESSE) = pos_nwords_finesse[ 2 ];
942 *(buf_to + m_reduced_rawcpr.tmp_header.POS_OFFSET_4TH_FINESSE) = pos_nwords_finesse[ 3 ];
943
944
945 // Recalculate XOR checksum in a RawCOPPER trailer
946 *(buf_to + pos_nwords_to - tmp_trailer.GetTrlNwords() + tmp_trailer.POS_CHKSUM) =
947 CalcXORChecksum(buf_to, pos_nwords_to - tmp_trailer.GetTrlNwords());
948
949 //
950 // data block # check
951 //
952 m_reduced_rawcpr.SetBuffer(buf_to, nwords_buf_to, 0, GetNumEvents(), GetNumNodes());
953 if (m_reduced_rawcpr.GetNumEvents() * m_reduced_rawcpr.GetNumNodes() <= 0) {
954 char err_buf[500];
955 sprintf(err_buf, "Invalid data block numbers.(# of events %d, # of nodes %d) Exiting...\n",
956 m_reduced_rawcpr.GetNumEvents(), m_reduced_rawcpr.GetNumNodes());
957 printf("%s", err_buf); fflush(stdout);
958 B2FATAL(err_buf);
959 }
960
961 //
962 // check no-data buffer
963 //
964 for (int i = 0; i < m_reduced_rawcpr.GetNumEvents() * m_reduced_rawcpr.GetNumNodes(); i++) {
965 int nonzero_finesse_buf = 0;
966 for (int j = 0; j < 4; j++) {
967
968 if (GetFINESSENwords(n, j) > 0) {
969 // m_reduced_rawcpr.CheckCRC16(i, j);
970 nonzero_finesse_buf++;
971 }
972 }
973 if (nonzero_finesse_buf == 0) {
974 char err_buf[500];
975 sprintf(err_buf, "No non-zero FINESSE buffer. Exiting...\n");
976 printf("%s", err_buf); fflush(stdout);
977 B2FATAL(err_buf);
978 }
979 }
980
981 // post_rawcopper_v1.CheckCRC16(0, 0);
982 // printf("fROM =======================================\n");
983 // for (int k = 0; k < nwords_buf_to; k++) {
984 // printf(" %.8x", GetBuffer(n)[ k ]);
985 // if ( ( k + 1 ) % 10 == 0) {
986 // printf("\n");
987 // }
988 // }
989 // printf("\n");
990
991 // printf("tO =======================================\n");
992 // for (int k = 0; k < nwords_buf_to; k++) {
993 // printf(" %.8x", buf_to[ k ]);
994 // if ( ( k + 1 ) % 10 == 0) {
995 // printf("\n");
996 // }
997 // }
998 // printf("\n");
999 // printf("=============================================\n");
1000 return pos_nwords_to;
1001}
1002
1003
1004int PreRawCOPPERFormat_v1::CheckB2LHSLBMagicWords(int* finesse_buf, int finesse_nwords)
1005{
1006
1007 if ((finesse_buf[ POS_MAGIC_B2LHSLB ] & 0xFFFF0000) == B2LHSLB_HEADER_MAGIC &&
1008 ((finesse_buf[ finesse_nwords - SIZE_B2LHSLB_TRAILER + POS_CHKSUM_B2LHSLB ] & 0xFFFF0000)
1009 == B2LHSLB_TRAILER_MAGIC)) {
1010 return 1;
1011 } else {
1012 PrintData(m_buffer, m_nwords);
1013 char err_buf[500];
1014 sprintf(err_buf, "Invalid B2LHSLB magic words 0x%x 0x%x. Exiting... :%s %s %d\n",
1015 finesse_buf[ POS_MAGIC_B2LHSLB ],
1016 finesse_buf[ finesse_nwords - SIZE_B2LHSLB_TRAILER + POS_CHKSUM_B2LHSLB ],
1017 __FILE__, __PRETTY_FUNCTION__, __LINE__);
1018 printf("%s", err_buf); fflush(stdout);
1019 B2FATAL(err_buf);
1020 return -1;
1021 }
1022}
1023
1024
1025
1026int PreRawCOPPERFormat_v1::CheckCRC16(int n, int finesse_num)
1027{
1028 //
1029 // Calculate CRC16
1030 //
1031 int* buf = GetFINESSEBuffer(n, finesse_num) + SIZE_B2LHSLB_HEADER;
1032 int nwords = GetFINESSENwords(n, finesse_num) - (static_cast<int>(SIZE_B2LHSLB_HEADER) + SIZE_B2LFEE_TRAILER +
1033 SIZE_B2LHSLB_TRAILER);
1034 unsigned short temp_crc16 = CalcCRC16LittleEndian(0xffff, buf, nwords);
1035
1036 //
1037 // Compare CRC16 with B2LCRC16
1038 //
1039 buf = GetFINESSEBuffer(n, finesse_num) + GetFINESSENwords(n, finesse_num)
1040 - ((SIZE_B2LFEE_TRAILER - POS_CHKSUM_B2LFEE) + SIZE_B2LHSLB_TRAILER) ;
1041
1042 // printf("PreRawCOPPER : Eve %.8x B2LCRC16 %.8x calculated CRC16 %.8x\n", GetEveNo(n), *buf, temp_crc16 );
1043
1044 if ((unsigned short)(*buf & 0xFFFF) != temp_crc16) {
1045 printf("PRE CRC16 error : B2LCRC16 %x Calculated CRC16 %x : Nwords of FINESSE buf %d\n",
1046 *buf, temp_crc16, GetFINESSENwords(n, finesse_num));
1047 int* temp_buf = GetFINESSEBuffer(n, finesse_num);
1048 for (int k = 0; k < GetFINESSENwords(n, finesse_num); k++) {
1049 printf("%.8x ", temp_buf[ k ]);
1050 if ((k + 1) % 10 == 0) {
1051 printf("\n");
1052 }
1053 }
1054 printf("\n");
1055 fflush(stdout);
1056
1057 char err_buf[500];
1058 sprintf(err_buf,
1059 "[DEBUG] [ERROR] B2LCRC16 (%.4x) differs from one ( %.4x) calculated by PreRawCOPPERfromat class. Exiting...\n %s %s %d\n",
1060 (unsigned short)(*buf & 0xFFFF), temp_crc16,
1061 __FILE__, __PRETTY_FUNCTION__, __LINE__);
1062 printf("%s", err_buf); fflush(stdout);
1063 B2FATAL(err_buf);
1064 }
1065 return 1;
1066
1067}
1068
1069int* PreRawCOPPERFormat_v1::PackDetectorBuf(int* packed_buf_nwords,
1070 int* detector_buf_1st, int nwords_1st,
1071 int* detector_buf_2nd, int nwords_2nd,
1072 int* detector_buf_3rd, int nwords_3rd,
1073 int* detector_buf_4th, int nwords_4th,
1074 RawCOPPERPackerInfo rawcpr_info)
1075{
1076 int* packed_buf = NULL;
1077
1078 int poswords_to = 0;
1079 int* detector_buf[ 4 ] = { detector_buf_1st, detector_buf_2nd, detector_buf_3rd, detector_buf_4th };
1080 const int nwords[ 4 ] = { nwords_1st, nwords_2nd, nwords_3rd, nwords_4th };
1081
1082 // calculate the event length
1083 int length_nwords = tmp_header.GetHdrNwords() + SIZE_COPPER_HEADER + SIZE_COPPER_TRAILER + tmp_trailer.GetTrlNwords();
1084
1085 for (int i = 0; i < 4; i++) {
1086 if (detector_buf[ i ] == NULL || nwords[ i ] <= 0) continue; // for an empty FINESSE slot
1087 length_nwords += nwords[ i ];
1088 length_nwords += static_cast<int>(SIZE_B2LHSLB_HEADER) + SIZE_B2LFEE_HEADER
1089 + SIZE_B2LFEE_TRAILER + SIZE_B2LHSLB_TRAILER;
1090 }
1091
1092 // allocate buffer
1093 packed_buf = new int[ length_nwords ];
1094 memset(packed_buf, 0, sizeof(int) * length_nwords);
1095
1096 //
1097 // Fill RawHeader
1098 //
1099 tmp_header.SetBuffer(packed_buf);
1100
1101 packed_buf[ tmp_header.POS_NWORDS ] = length_nwords; // total length
1102 packed_buf[ tmp_header.POS_VERSION_HDRNWORDS ] = 0x7f7f8000
1103 | ((DATA_FORMAT_VERSION << tmp_header.FORMAT_VERSION_SHIFT) & tmp_header.FORMAT_VERSION__MASK)
1104 | tmp_header.RAWHEADER_NWORDS; // ver.#, header length
1105
1106 packed_buf[ tmp_header.POS_EXP_RUN_NO ] = (rawcpr_info.exp_num << 22)
1107 | (rawcpr_info.run_subrun_num & 0x003FFFFF); // exp. and run #
1108 packed_buf[ tmp_header.POS_EVE_NO ] = rawcpr_info.eve_num; // eve #
1109 packed_buf[ tmp_header.POS_TTCTIME_TRGTYPE ] = (rawcpr_info.tt_ctime & 0x7FFFFFF) << 4; // tt_ctime
1110 packed_buf[ tmp_header.POS_TTUTIME ] = rawcpr_info.tt_utime; // tt_utime
1111 packed_buf[ tmp_header.POS_NODE_ID ] = rawcpr_info.node_id; // node ID
1112
1113
1114
1115
1116 // fill the positions of finesse buffers
1117 packed_buf[ tmp_header.POS_OFFSET_1ST_FINESSE ] = static_cast<int>(tmp_header.RAWHEADER_NWORDS) + SIZE_COPPER_HEADER;
1118
1119 packed_buf[ tmp_header.POS_OFFSET_2ND_FINESSE ] = packed_buf[ tmp_header.POS_OFFSET_1ST_FINESSE ];
1120 if (nwords[ 0 ] > 0) {
1121 packed_buf[ tmp_header.POS_OFFSET_2ND_FINESSE ] +=
1122 nwords[ 0 ] + SIZE_B2LHSLB_HEADER + SIZE_B2LFEE_HEADER + SIZE_B2LFEE_TRAILER + SIZE_B2LHSLB_TRAILER;
1123 }
1124
1125 packed_buf[ tmp_header.POS_OFFSET_3RD_FINESSE ] = packed_buf[ tmp_header.POS_OFFSET_2ND_FINESSE ];
1126 if (nwords[ 1 ] > 0) {
1127 packed_buf[ tmp_header.POS_OFFSET_3RD_FINESSE ] +=
1128 nwords[ 1 ] + SIZE_B2LHSLB_HEADER + SIZE_B2LFEE_HEADER + SIZE_B2LFEE_TRAILER + SIZE_B2LHSLB_TRAILER;
1129 }
1130
1131 packed_buf[ tmp_header.POS_OFFSET_4TH_FINESSE ] = packed_buf[ tmp_header.POS_OFFSET_3RD_FINESSE ];
1132 if (nwords[ 2 ] > 0) {
1133 packed_buf[ tmp_header.POS_OFFSET_4TH_FINESSE ] += nwords[ 2 ] + SIZE_B2LHSLB_HEADER + SIZE_B2LFEE_HEADER + SIZE_B2LFEE_TRAILER +
1134 SIZE_B2LHSLB_TRAILER;
1135 }
1136 poswords_to += tmp_header.GetHdrNwords();
1137
1138 // Fill COPPER header
1139 packed_buf[ poswords_to + POS_MAGIC_COPPER_1 ] = COPPER_MAGIC_DRIVER_HEADER;
1140 packed_buf[ poswords_to + POS_MAGIC_COPPER_2 ] = COPPER_MAGIC_FPGA_HEADER;
1141 packed_buf[ poswords_to + POS_EVE_NUM_COPPER ] = rawcpr_info.eve_num;
1142
1143 int size_b2l_hdrtrl = static_cast<int>(SIZE_B2LHSLB_HEADER) + SIZE_B2LFEE_HEADER + SIZE_B2LFEE_TRAILER + SIZE_B2LHSLB_TRAILER;
1144 if (nwords[ 0 ] != 0) packed_buf[ poswords_to + POS_CH_A_DATA_LENGTH ] = nwords[ 0 ] + size_b2l_hdrtrl;
1145 if (nwords[ 1 ] != 0) packed_buf[ poswords_to + POS_CH_B_DATA_LENGTH ] = nwords[ 1 ] + size_b2l_hdrtrl;
1146 if (nwords[ 2 ] != 0) packed_buf[ poswords_to + POS_CH_C_DATA_LENGTH ] = nwords[ 2 ] + size_b2l_hdrtrl;
1147 if (nwords[ 3 ] != 0) packed_buf[ poswords_to + POS_CH_D_DATA_LENGTH ] = nwords[ 3 ] + size_b2l_hdrtrl;
1148
1149 packed_buf[ poswords_to + POS_DATA_LENGTH ] =
1150 packed_buf[ poswords_to + POS_CH_A_DATA_LENGTH ] +
1151 packed_buf[ poswords_to + POS_CH_B_DATA_LENGTH ] +
1152 packed_buf[ poswords_to + POS_CH_C_DATA_LENGTH ] +
1153 packed_buf[ poswords_to + POS_CH_D_DATA_LENGTH ] +
1154 (static_cast<int>(SIZE_COPPER_HEADER) - SIZE_COPPER_DRIVER_HEADER) +
1155 (static_cast<int>(SIZE_COPPER_TRAILER) - SIZE_COPPER_DRIVER_TRAILER);
1156
1157 poswords_to += SIZE_COPPER_HEADER;
1158
1159 // Fill FINESSE buffer
1160 for (int i = 0; i < 4; i++) {
1161
1162 if (detector_buf[ i ] == NULL || nwords[ i ] <= 0) continue; // for an empty FINESSE slot
1163
1164 // Fill b2link HSLB header
1165 packed_buf[ poswords_to + POS_MAGIC_B2LHSLB ] = 0xffaa0000 | (0xffff & rawcpr_info.eve_num);
1166 poswords_to += SIZE_B2LHSLB_HEADER;
1167 int* crc16_start = &(packed_buf[ poswords_to ]);
1168
1169 // Fill b2link FEE header
1170
1171 packed_buf[ poswords_to + POS_TT_CTIME_TYPE ] = (rawcpr_info.tt_ctime & 0x7FFFFFF) << 4;
1172 packed_buf[ poswords_to + POS_TT_TAG ] = rawcpr_info.eve_num;
1173 packed_buf[ poswords_to + POS_TT_UTIME ] = rawcpr_info.tt_utime;
1174 packed_buf[ poswords_to + POS_EXP_RUN ] = (rawcpr_info.exp_num << 22) | (rawcpr_info.run_subrun_num &
1175 0x003FFFFF); // exp. and run #
1176 packed_buf[ poswords_to + POS_B2L_CTIME ] = (rawcpr_info.b2l_ctime & 0x7FFFFFF) << 4;
1177 poswords_to += SIZE_B2LFEE_HEADER;
1178
1179 // copy the 1st Detector Buffer
1180 memcpy(packed_buf + poswords_to, detector_buf[ i ], nwords[ i ]*sizeof(int));
1181 poswords_to += nwords[ i ];
1182
1183 // Fill b2link FEE trailer
1184 unsigned short crc16 = CalcCRC16LittleEndian(0xffff, crc16_start, nwords[ i ] + SIZE_B2LFEE_HEADER);
1185 packed_buf[ poswords_to + POS_CHKSUM_B2LFEE ] = ((0xffff & rawcpr_info.eve_num) << 16) | (crc16 & 0xffff);
1186 poswords_to += SIZE_B2LFEE_TRAILER;
1187
1188 // Fill b2link HSLB trailer
1189 packed_buf[ poswords_to + POS_CHKSUM_B2LHSLB ] = 0xff550000;
1190 poswords_to += SIZE_B2LHSLB_TRAILER;
1191
1192 }
1193
1194 // Fill COPPER trailer
1195 packed_buf[ poswords_to + POS_MAGIC_COPPER_3 ] = COPPER_MAGIC_FPGA_TRAILER;
1196 packed_buf[ poswords_to + POS_MAGIC_COPPER_4 ] = COPPER_MAGIC_DRIVER_TRAILER;
1197 unsigned int chksum = 0;
1198 for (int i = tmp_header.GetHdrNwords(); i < poswords_to + (static_cast<int>(SIZE_COPPER_TRAILER) - SIZE_COPPER_DRIVER_TRAILER);
1199 i++) {
1200 chksum ^= packed_buf[ i ];
1201 }
1202 packed_buf[ poswords_to + POS_CHKSUM_COPPER ] = chksum;
1203 poswords_to += SIZE_COPPER_TRAILER;
1204
1205 // Calculate RawCOPPER checksum and fill RawTrailer
1206 chksum = 0;
1207 for (int i = 0; i < poswords_to; i++) {
1208 chksum ^= packed_buf[ i ];
1209 }
1210 packed_buf[ poswords_to + tmp_trailer.POS_CHKSUM ] = chksum;
1211
1212 packed_buf[ poswords_to + tmp_trailer.POS_TERM_WORD ] = tmp_trailer.MAGIC_WORD_TERM_TRAILER;
1213 poswords_to += tmp_trailer.GetTrlNwords();
1214
1215 *packed_buf_nwords = poswords_to;
1216 return packed_buf;
1217}
1218
Belle2::PreRawCOPPERFormat_v1
The Raw COPPER class ver.1 ( the latest version since May, 2014 ) This class stores data received by ...
Definition: PreRawCOPPERFormat_v1.h:33
Belle2::PreRawCOPPERFormat_v1::CheckB2LHSLBMagicWords
int CheckB2LHSLBMagicWords(int *finesse_buf, int finesse_nwords)
check magic words of B2link HSLB header/trailer
Definition: PreRawCOPPERFormat_v1.cc:1004
Belle2::PreRawCOPPERFormat_v1::CopyReducedBuffer
int CopyReducedBuffer(int n, int *buf_to)
copy data to reduced buffer
Definition: PreRawCOPPERFormat_v1.cc:841
Belle2::PreRawCOPPERFormat_v1::CheckCRC16
int CheckCRC16(int n, int finesse_num)
check CRC16 in B2LFEE trailer
Definition: PreRawCOPPERFormat_v1.cc:1026
Belle2::PreRawCOPPERFormat_v1::PackDetectorBuf
int * PackDetectorBuf(int *packed_buf_nwords, int *detector_buf_1st, int nwords_1st, int *detector_buf_2nd, int nwords_2nd, int *detector_buf_3rd, int nwords_3rd, int *detector_buf_4th, int nwords_4th, RawCOPPERPackerInfo rawcprpacker_info) OVERRIDE_CPP17
Pack data (format ver. = -1 -> Select the latest format version)
Definition: PreRawCOPPERFormat_v1.cc:1069
Belle2::PreRawCOPPERFormat_v1::CalcReducedNwords
int CalcReducedNwords(int n)
calculate reduced data size
Definition: PreRawCOPPERFormat_v1.cc:801
Belle2::PreRawCOPPERFormat_v1::m_reduced_rawcpr
PostRawCOPPERFormat_v1 m_reduced_rawcpr
data fromat after size reduction
Definition: PreRawCOPPERFormat_v1.h:287
Belle2::PreRawCOPPERFormat_v1::PreRawCOPPERFormat_v1
PreRawCOPPERFormat_v1()
Default constructor.
Definition: PreRawCOPPERFormat_v1.cc:21
Belle2::PreRawCOPPERFormat_v1::CheckUtimeCtimeTRGType
void CheckUtimeCtimeTRGType(int n) OVERRIDE_CPP17
check data contents
Definition: PreRawCOPPERFormat_v1.cc:370
Belle2::PreRawCOPPERFormat_v1::CopyReducedData
void CopyReducedData(int *bufin, int nwords, int num_events, int num_nodes, int *buf_to, int *nwords_to)
reduce and merge header/trailer
Definition: PreRawCOPPERFormat_v1.cc:762
Belle2::PreRawCOPPERFormat_v1::FillTopBlockRawHeader
unsigned int FillTopBlockRawHeader(unsigned int m_node_id, unsigned int prev_eve32, unsigned int prev_exprunsubrun_no, unsigned int *cur_exprunsubrun_no) OVERRIDE_CPP17
should be called by DeSerializerCOPPER.cc and fill contents in RawHeader
Definition: PreRawCOPPERFormat_v1.cc:417
Belle2::PreRawCOPPERFormat_v1::GetB2LFEE32bitEventNumber
virtual unsigned int GetB2LFEE32bitEventNumber(int n) OVERRIDE_CPP17
get b2l block from "FEE b2link header"
Definition: PreRawCOPPERFormat_v1.cc:136
Belle2::PreRawCOPPERFormat_v1::CalcReducedDataSize
int CalcReducedDataSize(int *bufin, int nwords, int num_events, int num_nodes)
reduce and merge header/trailer
Definition: PreRawCOPPERFormat_v1.cc:727
Belle2::PreRawCOPPERFormat_v1::GetDetectorNwords
int GetDetectorNwords(int n, int finesse_num) OVERRIDE_CPP17
get Detector buffer length
Definition: PreRawCOPPERFormat_v1.cc:86
Belle2::PreRawCOPPERFormat_v1::CheckCOPPERMagic
bool CheckCOPPERMagic(int n) OVERRIDE_CPP17
Check if COPPER Magic words are correct.
Definition: PreRawCOPPERFormat_v1.cc:356
Belle2::PreRawCOPPERFormat_v1::CalcDriverChkSum
unsigned int CalcDriverChkSum(int n) OVERRIDE_CPP17
calc COPPER driver's checksum value
Definition: PreRawCOPPERFormat_v1.cc:72
Belle2::PreRawCOPPERFormat_v1::~PreRawCOPPERFormat_v1
virtual ~PreRawCOPPERFormat_v1()
Constructor using existing pointer to raw data buffer.
Definition: PreRawCOPPERFormat_v1.cc:25
Belle2::PreRawCOPPERFormat_v1::GetFINESSENwords
int GetFINESSENwords(int n, int finesse) OVERRIDE_CPP17
get data size of FINESSE buffer
Definition: PreRawCOPPERFormat_v1.cc:99
Belle2::PreRawCOPPERFormat_v1::CheckData
void CheckData(int n, unsigned int prev_evenum, unsigned int *cur_evenum, unsigned int prev_copper_ctr, unsigned int *cur_copper_ctr, unsigned int prev_exprunsubrun_no, unsigned int *cur_exprunsubrun_no) OVERRIDE_CPP17
check data contents
Definition: PreRawCOPPERFormat_v1.cc:191
Belle2::RawCOPPERFormat_v1::tmp_trailer
RawTrailer_v1 tmp_trailer
trailer ( not recorded )
Definition: RawCOPPERFormat_v1.h:186
Belle2::RawCOPPERFormat_v1::tmp_header
RawHeader_v1 tmp_header
header ( not recorded )
Definition: RawCOPPERFormat_v1.h:183
Belle2::RawCOPPERFormat::GetOffsetFINESSE
virtual int GetOffsetFINESSE(int n, int finesse)
get # of offset words
Definition: RawCOPPERFormat.cc:36
Belle2::RawCOPPERFormat::CalcXORChecksum
virtual unsigned int CalcXORChecksum(int *buf, int nwords)
calc XOR checksum
Definition: RawCOPPERFormat.cc:24
Belle2::RawCOPPERFormat::GetFINESSEBuffer
virtual int * GetFINESSEBuffer(int n, int finesse_num)
get FINESSE buffer pointer
Definition: RawCOPPERFormat.cc:65
Belle2::RawCOPPERPackerInfo
struct to contain header information used by RawCOPPERFormat::Packer()
Definition: RawCOPPERPackerInfo.h:19
Belle2::RawCOPPERPackerInfo::b2l_ctime
unsigned int b2l_ctime
32bit unitx time at trigger timing distributed by FTSW. For details, see Nakao-san's belle2link user ...
Definition: RawCOPPERPackerInfo.h:38
Belle2::RawCOPPERPackerInfo::eve_num
unsigned int eve_num
Run # and subrun # ( 22bit )
Definition: RawCOPPERPackerInfo.h:27
Belle2::RawCOPPERPackerInfo::tt_ctime
unsigned int tt_ctime
Node ID (32bit)
Definition: RawCOPPERPackerInfo.h:32
Belle2::RawCOPPERPackerInfo::tt_utime
unsigned int tt_utime
27bit clock ticks at trigger timing distributed by FTSW. For details, see Nakao-san's belle2link user...
Definition: RawCOPPERPackerInfo.h:35
Belle2::RawCOPPERPackerInfo::node_id
unsigned int node_id
Event Number (32bit)
Definition: RawCOPPERPackerInfo.h:29
Belle2::RawCOPPERPackerInfo::run_subrun_num
unsigned int run_subrun_num
Experiment number (10bit)
Definition: RawCOPPERPackerInfo.h:25
Belle2::RawCOPPERPackerInfo::exp_num
unsigned int exp_num
Experiment number (10bit)
Definition: RawCOPPERPackerInfo.h:23
Belle2::RawDataBlockFormat::GetBlockNwords
virtual int GetBlockNwords(int n)
get size of a data block
Definition: RawDataBlockFormat.cc:107
Belle2::RawDataBlockFormat::CheckFTSWID
virtual int CheckFTSWID(int n)
get FTSW ID to check whether this data block is FTSW data or not
Definition: RawDataBlockFormat.cc:73
Belle2::RawDataBlockFormat::CopyBlock
virtual void CopyBlock(int n, int *buf_to)
Copy one datablock to buffer.
Definition: RawDataBlockFormat.cc:173
Belle2::RawDataBlockFormat::GetBufferPos
virtual int GetBufferPos(int n)
get position of data block in word
Definition: RawDataBlockFormat.cc:30
Belle2::RawDataBlockFormat::SetBuffer
virtual void SetBuffer(int *bufin, int nwords, int delete_flag, int num_events, int num_nodes)
set buffer ( delete_flag : m_buffer is freeed( = 0 )/ not freeed( = 1 ) in Destructer )
Definition: RawDataBlockFormat.cc:131
Belle2::RawDataBlockFormat::GetNumNodes
virtual int GetNumNodes()
get # of data sources(e.g. # of COPPER boards) in m_buffer
Definition: RawDataBlockFormat.h:52
Belle2::RawDataBlockFormat::GetBuffer
virtual int * GetBuffer(int n)
get nth buffer pointer
Definition: RawDataBlockFormat.cc:124
Belle2::RawDataBlockFormat::m_nwords
int m_nwords
number of words of buffer
Definition: RawDataBlockFormat.h:89
Belle2::RawDataBlockFormat::GetNumEvents
virtual int GetNumEvents()
get # of events in m_buffer
Definition: RawDataBlockFormat.h:55
Belle2::RawDataBlockFormat::PrintData
virtual void PrintData(int *buf, int nwords)
print data
Definition: RawDataBlockFormat.cc:161
Belle2::RawDataBlockFormat::CheckTLUID
virtual int CheckTLUID(int n)
get FTSW ID to check whether this data block is FTSW data or not
Definition: RawDataBlockFormat.cc:88
Belle2::RawHeader_v1::SetBuffer
void SetBuffer(int *bufin)
set buffer
Definition: RawHeader_v1.h:47
Belle2::PreRawCOPPERFormat_v1::GetMagicFPGATrailer
unsigned int GetMagicFPGATrailer(int n) OVERRIDE_CPP17
get magic word of COPPER FPGA trailer
Definition: PreRawCOPPERFormat_v1.h:375
Belle2::PreRawCOPPERFormat_v1::GetMagicDriverTrailer
unsigned int GetMagicDriverTrailer(int n) OVERRIDE_CPP17
get magic word of COPPER driver trailer
Definition: PreRawCOPPERFormat_v1.h:384
Belle2::RawHeader_v1::GetHdrNwords
int GetHdrNwords()
get contents of header
Definition: RawHeader_v1.h:346
Belle2::RawTrailer_v1::GetTrlNwords
int GetTrlNwords()
Set magic word.
Definition: RawTrailer_v1.h:132
Belle2::PreRawCOPPERFormat_v1::GetMagicFPGAHeader
unsigned int GetMagicFPGAHeader(int n) OVERRIDE_CPP17
get magic word of COPPER FPGA header
Definition: PreRawCOPPERFormat_v1.h:369
Belle2::PreRawCOPPERFormat_v1::GetMagicDriverHeader
unsigned int GetMagicDriverHeader(int n) OVERRIDE_CPP17
get magic word of COPPER driver header
Definition: PreRawCOPPERFormat_v1.h:363
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17
std
STL namespace.