Belle II Software  release-08-01-10
PreRawCOPPERFormat_latest.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_latest.h>
10 
11 
12 using namespace std;
13 using namespace Belle2;
14 
15 //#define NO_ERROR_STOP
16 //#define WO_FIRST_EVENUM_CHECK
17 
18 //ClassImp(PreRawCOPPERFormat_latest);
19 
20 PreRawCOPPERFormat_latest::PreRawCOPPERFormat_latest()
21 {
22 }
23 
24 PreRawCOPPERFormat_latest::~PreRawCOPPERFormat_latest()
25 {
26 }
27 
28 unsigned int PreRawCOPPERFormat_latest::CalcDriverChkSum(int n)
29 {
30  int min = GetBufferPos(n) + tmp_header.RAWHEADER_NWORDS;
31  int max = GetBufferPos(n) + GetBlockNwords(n)
32  - tmp_trailer.RAWTRAILER_NWORDS - SIZE_COPPER_DRIVER_TRAILER;
33  unsigned int chksum = 0;
34  for (int i = min; i < max; i++) {
35  chksum ^= m_buffer[ i ];
36  }
37  return chksum;
38 }
39 
40 unsigned int PreRawCOPPERFormat_latest::GetB2LFEE32bitEventNumber(int n)
41 {
42 
43 #ifndef READ_OLD_B2LFEE_FORMAT_FILE
44 
45  int err_flag = 0;
46  unsigned int eve_num = 0;
47  int flag = 0;
48  unsigned int eve[MAX_PCIE40_CH];
49  for (int i = 0; i < MAX_PCIE40_CH; i++) {
50  eve[ i ] = 0xbaadf00d;
51  if (GetFINESSENwords(n, i) > 0) {
52  int pos_nwords = GetOffsetFINESSE(n, i) + SIZE_B2LHSLB_HEADER + POS_TT_TAG;
53  eve[ i ] = m_buffer[ pos_nwords ];
54  if (flag != 1) eve_num = eve[ i ];
55  if (eve_num != eve[ i ]) err_flag = 1;
56  flag = 1;
57  }
58  }
59 
60  if (flag == 0) {
61  PrintData(m_buffer, m_nwords);
62  char err_buf[500];
63  char hostname[128];
64  GetNodeName(n, hostname, sizeof(hostname));
65  sprintf(err_buf,
66  "[FATAL] %s ch=%d : ERROR_EVENT : No HSLB data in COPPER data. Exiting... : eve 0x%x exp %d run %d sub %d\n %s %s %d\n",
67  hostname, -1,
68  GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n),
69  __FILE__, __PRETTY_FUNCTION__, __LINE__);
70  printf("%s", err_buf); fflush(stdout);
71  // string err_str = err_buf; throw (err_str);
72  B2FATAL(err_buf); // to reduce multiple error messages
73  }
74 
75  if (err_flag == 1) {
76  vector<vector<unsigned int>> summary_table;
77  CompareHeaderValue(n, eve, summary_table);
78 
79  char err_buf[3000];
80  char err_buf_temp[2500];
81  char hostname[128];
82  GetNodeName(n, hostname, sizeof(hostname));
83  sprintf(err_buf, "[FATAL] %s ch=%d : ERROR_EVENT : CORRUPTED DATA: Different event number over HSLBs :", hostname, -1);
84  for (unsigned i = 0; i < summary_table.size(); ++i) {
85  memcpy(err_buf_temp, err_buf, sizeof(err_buf_temp));
86  sprintf(err_buf, "%s [ch= %u ,val= %u (# of chs= %u )] ",
87  err_buf_temp,
88  summary_table.at(i).at(0), summary_table.at(i).at(2), summary_table.at(i).at(1));
89  }
90  memcpy(err_buf_temp, err_buf, sizeof(err_buf_temp));
91  sprintf(err_buf, "%s : eve 0x%x exp %d run %d sub %d\n%s %s %d\n",
92  err_buf_temp,
93  GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n),
94  __FILE__, __PRETTY_FUNCTION__, __LINE__);
95 
96  printf("[DEBUG] %s\n", err_buf);
97  PrintData(m_buffer, m_nwords);
98  for (int i = 0; i < MAX_PCIE40_CH; ++i) {
99  printf("[DEBUG] ========== CRC check : block # %d finesse %d ==========\n", n, i);
100  if (GetFINESSENwords(n, i) > 0) {
101  CheckCRC16(n, i);
102  }
103  }
104  printf("[DEBUG] ========== No CRC error. : block %d =========\n", n);
105 #ifndef NO_ERROR_STOP
106  // string err_str = err_buf; throw (err_str);
107  B2FATAL(err_buf); // to reduce multiple error messages
108 #endif //NO_ERROR_STOP
109  }
110  return eve_num;
111 
112 #else // READ_OLD_B2LFEE_FORMAT_FILE
113 
114  char err_buf[500];
115  sprintf(err_buf, "[FATAL] You need comment out READ_OLD_B2LFEE_FORMAT_FILE if you are handling a new data format\n%s %s %d\n",
116  __FILE__, __PRETTY_FUNCTION__, __LINE__);
117  printf("%s", err_buf); fflush(stdout);
118  B2FATAL(err_buf); // to reduce multiple error messages
119 #endif // READ_OLD_B2LFEE_FORMAT_FILE
120 
121 }
122 
123 
124 void PreRawCOPPERFormat_latest::CheckData(int n,
125  unsigned int prev_evenum, unsigned int* cur_evenum_rawcprhdr,
126  unsigned int prev_copper_ctr, unsigned int* cur_copper_ctr,
127  unsigned int prev_exprunsubrun_no, unsigned int* cur_exprunsubrun_no)
128 {
129 
130  char err_buf[3000];
131  int err_flag = 0;
132 
133  //
134  // Event # check
135  //
136  *cur_evenum_rawcprhdr = GetEveNo(n);
137  unsigned int evenum_feehdr = GetB2LFEE32bitEventNumber(n);
138  if (*cur_evenum_rawcprhdr != evenum_feehdr) {
139  char hostname[128];
140  GetNodeName(n, hostname, sizeof(hostname));
141  sprintf(err_buf,
142  "[FATAL] %s ch=%d : ERROR_EVENT : Event # in PreRawCOPPERFormat_latest header and FEE header is different : cprhdr 0x%x feehdr 0x%x : Exiting... : eve 0x%x exp %d run %d sub %d\n%s %s %d\n",
143  hostname, -1,
144  *cur_evenum_rawcprhdr, evenum_feehdr,
145  GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n),
146  __FILE__, __PRETTY_FUNCTION__, __LINE__);
147  err_flag = 1;
148  }
149 
150  //
151  // Check incrementation of event #
152  //
153  *cur_exprunsubrun_no = GetExpRunSubrun(n);
154  *cur_copper_ctr = GetCOPPERCounter(n);
155  if (prev_exprunsubrun_no == *cur_exprunsubrun_no) {
156  if ((unsigned int)(prev_evenum + 1) != *cur_evenum_rawcprhdr) {
157  char hostname[128];
158  GetNodeName(n, hostname, sizeof(hostname));
159  sprintf(err_buf,
160  "[FATAL] %s ch=%d : ERROR_EVENT : Event # jump : i %d prev 0x%x cur 0x%x : prevrun %.8x currun %.8x: Exiting... : eve 0x%x exp %d run %d sub %d\n%s %s %d\n",
161  hostname, -1,
162  n, prev_evenum, *cur_evenum_rawcprhdr, prev_exprunsubrun_no, *cur_exprunsubrun_no,
163  GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n),
164  __FILE__, __PRETTY_FUNCTION__, __LINE__);
165  err_flag = 1;
166  }
167  if ((unsigned int)(prev_copper_ctr + 1) != *cur_copper_ctr) {
168  char hostname[128];
169  GetNodeName(n, hostname, sizeof(hostname));
170  sprintf(err_buf,
171  "[FATAL] %s ch=%d : ERROR_EVENT : COPPER counter jump : i %d prev 0x%x cur 0x%x : eve 0x%x exp %d run %d sub %d\n%s %s %d\n",
172  hostname, -1,
173  n, prev_copper_ctr, *cur_copper_ctr,
174  GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n),
175  __FILE__, __PRETTY_FUNCTION__, __LINE__);
176  err_flag = 1;
177  }
178  } else {
179  printf("[DEBUG] New run started. cur run %.8x prev. run %.8x cur eve %.8x prev eve %8.x : eve 0x%x exp %d run %d sub %d\n",
180  *cur_exprunsubrun_no, prev_exprunsubrun_no, *cur_evenum_rawcprhdr, prev_evenum,
181  GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n));
182 
183  // Check if the first event of a run is zero.
184  if ((unsigned int)GetRunNo(n) != (prev_exprunsubrun_no & RawHeader_latest::RUNNO_MASK) >> RawHeader_latest::RUNNO_SHIFT) {
185  if (*cur_evenum_rawcprhdr != 0) {
186 
187  unsigned int eve[MAX_PCIE40_CH];
188  for (int i = 0; i < MAX_PCIE40_CH ; ++i) {
189  eve[ i ] = 0xbaadf00d;
190  if (GetFINESSENwords(n, i) > 0) {
191  int pos_nwords = GetOffsetFINESSE(n, i) + SIZE_B2LHSLB_HEADER + POS_TT_TAG;
192  eve[ i ] = m_buffer[ pos_nwords ];
193  }
194  }
195 
196  vector<vector<unsigned int>> summary_table;
197  CompareHeaderValue(n, eve, summary_table);
198  char hostname[128];
199  GetNodeName(n, hostname, sizeof(hostname));
200  sprintf(err_buf,
201  "[FATAL] %s ch=%d : ERROR_EVENT : Invalid Event # at the beginning of the run (It should be zero.): preveve 0x%x cureve 0x%x : prev(exp %u run %u sub %u ) cur(exp %u run %u sub %u ) (",
202  hostname, -1,
203  prev_evenum, *cur_evenum_rawcprhdr,
204  prev_exprunsubrun_no >> 22, (prev_exprunsubrun_no >> 8) & 0x3FFF, prev_exprunsubrun_no & 0xFF,
205  *cur_exprunsubrun_no >> 22, (*cur_exprunsubrun_no >> 8) & 0x3FFF, *cur_exprunsubrun_no & 0xFF);
206 
207  char err_buf_temp[2500];
208  for (unsigned i = 0; i < summary_table.size(); ++i) {
209  memcpy(err_buf_temp, err_buf, sizeof(err_buf_temp));
210  sprintf(err_buf, "%s [ch= %u ,val= %u (# of chs= %u )] ",
211  err_buf_temp,
212  summary_table.at(i).at(0), summary_table.at(i).at(2), summary_table.at(i).at(1));
213  }
214  memcpy(err_buf_temp, err_buf, sizeof(err_buf_temp));
215  sprintf(err_buf, "%s Exiting... : eve 0x%x exp %d run %d sub %d\n%s %s %d\n",
216  err_buf_temp,
217  GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n),
218  __FILE__, __PRETTY_FUNCTION__, __LINE__);
219  err_flag = 1;
220  }
221  }
222  }
223 
224 
225 
226  //
227  // Check is utime and ctime_trgtype same over different FINESSE data
228  //
229  CheckUtimeCtimeTRGType(n);
230 
231  //
232  // Check checksum calculated by COPPER driver
233  //
234  if (GetDriverChkSum(n) != CalcDriverChkSum(n)) {
235  char hostname[128];
236  GetNodeName(n, hostname, sizeof(hostname));
237  sprintf(err_buf,
238  "[FATAL] %s ch=%d : ERROR_EVENT : COPPER driver checkSum error : block %d : length %d eve 0x%x : Trailer chksum 0x%.8x : calcd. now 0x%.8x : eve 0x%x exp %d run %d sub %d\n%s %s %d\n",
239  hostname, -1,
240  n, GetBlockNwords(n), *cur_evenum_rawcprhdr, GetDriverChkSum(n), CalcDriverChkSum(n),
241  GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n),
242  __FILE__, __PRETTY_FUNCTION__, __LINE__);
243  err_flag = 1;
244  }
245 
246  //
247  // Check checksum calculated by DeSerializerCOPPER()
248  //
249  tmp_trailer.SetBuffer(GetRawTrlBufPtr(n));
250  unsigned int xor_chksum = CalcXORChecksum(GetBuffer(n), GetBlockNwords(n) - tmp_trailer.GetTrlNwords());
251  if (tmp_trailer.GetChksum() != xor_chksum) {
252  char hostname[128];
253  GetNodeName(n, hostname, sizeof(hostname));
254  sprintf(err_buf,
255  "[FATAL] %s ch=%d : ERROR_EVENT : PreRawCOPPERFormat_latest checksum error : block %d : length %d eve 0x%x : Trailer chksum 0x%.8x : calcd. now 0x%.8x : eve 0x%x exp %d run %d sub %d\n %s %s %d\n",
256  hostname, -1,
257  n, GetBlockNwords(n), *cur_evenum_rawcprhdr, tmp_trailer.GetChksum(), xor_chksum,
258  GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n),
259  __FILE__, __PRETTY_FUNCTION__, __LINE__);
260  err_flag = 1;
261  }
262 
263  if (err_flag == 1) {
264  printf("%s", err_buf); fflush(stdout);
265  printf("[DEBUG] ========== dump a data blcok : block # %d==========\n", n);
266  PrintData(GetBuffer(n), GetBlockNwords(n));
267  for (int i = 0; i < MAX_PCIE40_CH; i++) {
268  printf("[DEBUG] ========== CRC check : block # %d finesse %d ==========\n", n, i);
269  if (GetFINESSENwords(n, i) > 0) {
270  CheckCRC16(n, i);
271  }
272  }
273  printf("[DEBUG] ========== No CRC error : block %d =========\n", n);
274  // string err_str = err_buf; throw (err_str);
275  B2FATAL(err_buf); // to reduce multiple error messages
276  }
277 
278  return;
279 
280 }
281 
282 bool PreRawCOPPERFormat_latest::CheckCOPPERMagic(int /*n*/)
283 {
284  char err_buf[500];
285  sprintf(err_buf, "[FATAL] This function is not supported. Exiting...: \n%s %s %d\n",
286  __FILE__, __PRETTY_FUNCTION__, __LINE__);
287  printf("[DEBUG] %s\n", err_buf);
288  B2FATAL(err_buf);
289  return false;
290 }
291 
292 void PreRawCOPPERFormat_latest::CheckUtimeCtimeTRGType(int n)
293 {
294 
295 #ifdef USE_B2LFEE_FORMAT_BOTH_VER1_AND_2
296  CheckB2LFEEHeaderVersion(n);
297 #endif
298  int err_flag = 0;
299  int flag = 0;
300  unsigned int temp_utime = 0, temp_ctime_trgtype = 0, temp_eve = 0, temp_exprun = 0;
301  unsigned int temp_ctime_trgtype_footer, temp_eve_footer;
302  unsigned int utime[MAX_PCIE40_CH], ctime_trgtype[MAX_PCIE40_CH], eve[MAX_PCIE40_CH], exprun[MAX_PCIE40_CH];
303  char err_buf[4000];
304 
305  memset(utime, 0, sizeof(utime));
306  memset(ctime_trgtype, 0, sizeof(ctime_trgtype));
307  memset(eve, 0, sizeof(eve));
308  memset(exprun, 0, sizeof(exprun));
309 
310  int first_ch = 0;
311  for (int i = 0; i < MAX_PCIE40_CH; i++) {
312  int finesse_nwords = GetFINESSENwords(n, i);
313  if (finesse_nwords > 0) {
314  int offset_finesse = GetOffsetFINESSE(n, i);
315  ctime_trgtype[ i ] = m_buffer[ offset_finesse + SIZE_B2LHSLB_HEADER + POS_TT_CTIME_TYPE ];
316  utime[ i ] = m_buffer[ offset_finesse + SIZE_B2LHSLB_HEADER + POS_TT_UTIME ];
317  eve[ i ] = m_buffer[ offset_finesse + SIZE_B2LHSLB_HEADER + POS_TT_TAG ];
318  exprun[ i ] = m_buffer[ offset_finesse + SIZE_B2LHSLB_HEADER + POS_EXP_RUN ];
319  temp_ctime_trgtype_footer =
320  m_buffer[ offset_finesse + finesse_nwords - (static_cast<int>(SIZE_B2LFEE_TRAILER) + SIZE_B2LHSLB_TRAILER) + POS_TT_CTIME_B2LFEE ];
321  temp_eve_footer =
322  m_buffer[ offset_finesse + finesse_nwords - (static_cast<int>(SIZE_B2LFEE_TRAILER) + SIZE_B2LHSLB_TRAILER) + POS_CHKSUM_B2LFEE ];
323 
324  if (flag == 0) {
325  temp_ctime_trgtype = ctime_trgtype[ i ];
326  temp_utime = utime[ i ];
327  temp_eve = eve[ i ];
328  temp_exprun = exprun[ i ];
329  flag = 1;
330  first_ch = i;
331  } else {
332  if (temp_ctime_trgtype != ctime_trgtype[ i ] || temp_utime != utime[ i ] ||
333  temp_eve != eve[ i ] || temp_exprun != exprun[ i ]) {
334  char hostname[128];
335  GetNodeName(n, hostname, sizeof(hostname));
336  if (err_flag == 0) {
337  for (int j = 0; j < MAX_PCIE40_CH; j++) {
338  if (GetFINESSENwords(n, j) > 0) {
339  printf("[DEBUG] %s ch=%d : FINESSE #=%d buffsize %d ctimeTRGtype 0x%.8x utime 0x%.8x eve 0x%.8x exprun 0x%.8x\n",
340  hostname, -1,
341  j, GetFINESSENwords(n, j), ctime_trgtype[ j ], utime[ j ], eve[ j ], exprun[ j ]);
342  }
343  }
344  }
345 
346  char err_buf_1[2500], err_buf_2[3000], err_buf_3[3500];
347  sprintf(err_buf_1,
348  "[FATAL] %s ch=%d : ERROR_EVENT : mismatch header value over FINESSEs. Exiting...",
349  hostname, -1);
350  sprintf(err_buf_2,
351  "%s FINESSE #=%d buffsize %d ctimeTRGtype 0x%.8x utime 0x%.8x eve 0x%.8x exprun 0x%.8x",
352  err_buf_1,
353  first_ch, GetFINESSENwords(n, first_ch), ctime_trgtype[ first_ch ], utime[ first_ch ], eve[ first_ch ], exprun[ first_ch ]);
354  sprintf(err_buf_3,
355  "%s FINESSE #=%d buffsize %d ctimeTRGtype 0x%.8x utime 0x%.8x eve 0x%.8x exprun 0x%.8x",
356  err_buf_2,
357  i, GetFINESSENwords(n, i), ctime_trgtype[ i ], utime[ i ], eve[ i ], exprun[ i ]);
358  sprintf(err_buf, "%s\n %s %s %d\n",
359  err_buf_3,
360  __FILE__, __PRETTY_FUNCTION__, __LINE__);
361  printf("%s", err_buf); fflush(stdout);
362 
363  err_flag = 1;
364  break;
365  } else if (temp_ctime_trgtype != temp_ctime_trgtype_footer ||
366  (temp_eve & 0xffff) != ((temp_eve_footer >> 16) & 0xffff)) {
367  char hostname[128];
368  GetNodeName(n, hostname, sizeof(hostname));
369  sprintf(err_buf,
370  "[FATAL] %s ch=%d : ERROR_EVENT : mismatch(finesse %d) between header(ctime %.8x eve %.8x) and footer(ctime %.8x eve_crc16 %.8x). Exiting...\n %s %s %d\n",
371  hostname, i,
372  i, temp_ctime_trgtype, temp_eve, temp_ctime_trgtype_footer, temp_eve_footer,
373  __FILE__, __PRETTY_FUNCTION__, __LINE__);
374  printf("%s", err_buf); fflush(stdout);
375  err_flag = 1;
376  }
377  }
378  }
379  }
380 
381  if (err_flag != 0) {
382  for (int i = 0; i < MAX_PCIE40_CH; i++) {
383  if (GetFINESSENwords(n, i) > 0) {
384  printf("[DEBUG] ========== CRC check : block # %d finesse %d ==========\n", n, i);
385  CheckCRC16(n, i);
386  printf("[DEBUG] ========== CRC check is done. : block %d =========\n", n);
387  }
388  }
389 #ifndef NO_ERROR_STOP
390  // string err_str = err_buf; throw (err_str);
391  B2FATAL(err_buf); // to reduce multiple error messages
392 #endif
393  }
394  return;
395 }
396 
397 unsigned int PreRawCOPPERFormat_latest::FillTopBlockRawHeader(unsigned int /*m_node_id*/, unsigned int /*prev_eve32*/,
398  unsigned int /*prev_exprunsubrun_no*/, unsigned int* /*cur_exprunsubrun_no*/)
399 {
400  char err_buf[500];
401  sprintf(err_buf, "[FATAL] This function is not supported. Exiting...: \n%s %s %d\n",
402  __FILE__, __PRETTY_FUNCTION__, __LINE__);
403  printf("[DEBUG] %s\n", err_buf);
404  B2FATAL(err_buf);
405  return 0;
406 }
407 
408 
409 
410 #ifdef USE_B2LFEE_FORMAT_BOTH_VER1_AND_2
411 void PreRawCOPPERFormat_latest::CheckB2LFEEHeaderVersion(int n)
412 {
413  int* temp_buf;
414  for (int i = 0; i < MAX_PCIE40_CH; i++) {
415  if (GetFINESSENwords(n, i) > 0) {
416  temp_buf = GetFINESSEBuffer(n, i);
417  if ((temp_buf[ 3 ] & 0x40000000) == 0) {
418 #ifdef TEMP
419  // this word for exp/run
420  // old one (ver.1) used for SPring8 test in 2013
421  printf("[DEBUG] \033[31m");
422  printf("[DEBUG] ===Firmware ver. ERROR===\n ");
423  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");
424  printf("[DEBUG] If you are going to take data now, Please update the firmware.\n");
425  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");
426  printf("[DEBUG] Or if you are going to read data taken before the update, please use basf2 software before svn revision 7419\n");
427  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");
428  printf("[DEBUG] Sorry for inconvenience.\n");
429  printf("[DEBUG] \033[0m");
430  fflush(stderr);
431  char err_buf[500];
432  char hostname[128];
433  GetNodeName(n, hostname, sizeof(hostname));
434  sprintf(err_buf, "[FATAL] %s ch=%d : ERROR_EVENT : FTSW and b2tt firmwares are old. Exiting...\n %s %s %d\n",
435  hostname, i,
436  __FILE__, __PRETTY_FUNCTION__, __LINE__);
437  B2FATAL(err_buf);
438 #endif
439  } else {
440  // this word for 32bit unixtime
441  // new one (ver.2)
442  break;
443  }
444  }
445 
446  if (i == MAX_PCIE40_CH - 1) {
447 #ifdef TEMP
448  char err_buf[500];
449  char hostname[128];
450  GetNodeName(n, hostname, sizeof(hostname));
451  sprintf(err_buf, "[FATAL] %s ch=%d : ERROR_EVENT : PreRawCOPPERFormat_latest contains no FINESSE data. Exiting...\n %s %s %d\n",
452  hostname, i,
453  __FILE__, __PRETTY_FUNCTION__, __LINE__);
454  printf("%s", err_buf); fflush(stdout);
455  // string err_str = err_buf; throw (err_str);
456  B2FATAL(err_buf); // to reduce multiple error messages
457 #endif
458  }
459  }
460  return;
461 }
462 #endif
463 
464 //int PreRawCOPPERFormat_latest::CalcReducedDataSize(RawDataBlock* raw_datablk)
465 int PreRawCOPPERFormat_latest::CalcReducedDataSize(int* bufin, int nwords, int num_events, int num_nodes)
466 {
467  //
468  // Calculate reduced length for a total RawDataBlock (containing multiple data blocks)
469  //
470  RawDataBlockFormat radblk_fmt;
471  int delete_flag = 0;
472  radblk_fmt.SetBuffer(bufin, nwords, delete_flag, num_events, num_nodes);
473 
474  int reduced_nwords = 0;
475  for (int k = 0; k < radblk_fmt.GetNumEvents(); k++) {
476  int num_nodes_in_sendblock = radblk_fmt.GetNumNodes();
477  for (int l = 0; l < num_nodes_in_sendblock; l++) {
478  int entry_id = l + k * num_nodes_in_sendblock;
479 
480  if (radblk_fmt.CheckFTSWID(entry_id) || radblk_fmt.CheckTLUID(entry_id)) {
481  reduced_nwords += radblk_fmt.GetBlockNwords(entry_id);
482  } else {
483  PreRawCOPPERFormat_latest temp_prerawcpr;
484  int temp_delete_flag = 0, temp_num_eve = 1, temp_num_nodes = 1;
485 
486  // Call CalcReducedNwords
487  temp_prerawcpr.SetBuffer(radblk_fmt.GetBuffer(entry_id),
488  radblk_fmt.GetBlockNwords(entry_id),
489  temp_delete_flag, temp_num_eve,
490  temp_num_nodes);
491  reduced_nwords += temp_prerawcpr.CalcReducedNwords(0);
492  }
493  }
494  }
495  return reduced_nwords;
496 
497 }
498 
499 //void PreRawCOPPERFormat_latest::CopyReducedData(RawDataBlock* raw_datablk, int* buf_to, int delete_flag_from)
500 void PreRawCOPPERFormat_latest::CopyReducedData(int* bufin, int nwords, int num_events, int num_nodes, int* buf_to, int* nwords_to)
501 {
502  //
503  // Make a reduced buffer a total RawDataBlock (containing multiple data blocks)
504  //
505  RawDataBlockFormat radblk_fmt;
506  int delete_flag = 0;
507  radblk_fmt.SetBuffer(bufin, nwords, delete_flag, num_events, num_nodes);
508 
509  int pos_nwords_to = 0;
510  for (int k = 0; k < radblk_fmt.GetNumEvents(); k++) {
511  int num_nodes_in_sendblock = radblk_fmt.GetNumNodes();
512  for (int l = 0; l < num_nodes_in_sendblock; l++) {
513  int entry_id = l + k * num_nodes_in_sendblock;
514  if (radblk_fmt.CheckFTSWID(entry_id) ||
515  radblk_fmt.CheckTLUID(entry_id)) {
516  radblk_fmt.CopyBlock(entry_id, buf_to + pos_nwords_to);
517  pos_nwords_to += radblk_fmt.GetBlockNwords(entry_id);
518 
519  } else {
520  SetBuffer(radblk_fmt.GetBuffer(entry_id),
521  radblk_fmt.GetBlockNwords(entry_id), 0, 1, 1);
522 
523  pos_nwords_to += CopyReducedBuffer(0, buf_to + pos_nwords_to);
524 
525 
526  }
527  }
528  }
529 
530  *nwords_to = pos_nwords_to;
531 
532  return ;
533 }
534 
535 
536 int PreRawCOPPERFormat_latest::CalcReducedNwords(int /*n*/)
537 {
538  char err_buf[500];
539  sprintf(err_buf, "[FATAL] This function is not supported. Exiting...: \n%s %s %d\n",
540  __FILE__, __PRETTY_FUNCTION__, __LINE__);
541  printf("[DEBUG] %s\n", err_buf);
542  B2FATAL(err_buf);
543  return -1;
544 }
545 
546 
547 int PreRawCOPPERFormat_latest::CopyReducedBuffer(int /*n*/, int* /*buf_to*/)
548 {
549  char err_buf[500];
550  sprintf(err_buf, "[FATAL] This function is not supported. Exiting...: \n%s %s %d\n",
551  __FILE__, __PRETTY_FUNCTION__, __LINE__);
552  printf("[DEBUG] %s\n", err_buf);
553  B2FATAL(err_buf);
554  return -1;
555 }
556 
557 
558 int PreRawCOPPERFormat_latest::CheckB2LHSLBMagicWords(int* finesse_buf, int finesse_nwords)
559 {
560 
561  if ((finesse_buf[ POS_MAGIC_B2LHSLB ] & 0xFFFF0000) == B2LHSLB_HEADER_MAGIC &&
562  ((finesse_buf[ finesse_nwords - SIZE_B2LHSLB_TRAILER + POS_CHKSUM_B2LHSLB ] & 0xFFFF0000)
563  == B2LHSLB_TRAILER_MAGIC)) {
564  return 1;
565  } else {
566  PrintData(m_buffer, m_nwords);
567  char err_buf[500];
568  sprintf(err_buf,
569  "Invalid B2LHSLB magic words : header 0x%x (= should be ffaa**** ) or trailer 0x%x (= should be ff55**** ). Exiting... :%s %s %d\n",
570  finesse_buf[ POS_MAGIC_B2LHSLB ],
571  finesse_buf[ finesse_nwords - SIZE_B2LHSLB_TRAILER + POS_CHKSUM_B2LHSLB ],
572  __FILE__, __PRETTY_FUNCTION__, __LINE__);
573 #ifndef NO_ERROR_STOP
574  printf("%s", err_buf); fflush(stdout);
575  B2FATAL(err_buf);
576 #endif
577  }
578 }
579 
580 
581 
582 int PreRawCOPPERFormat_latest::CheckCRC16(int n, int finesse_num)
583 {
584  //
585  // Calculate CRC16
586  //
587  int* buf = GetFINESSEBuffer(n, finesse_num) + SIZE_B2LHSLB_HEADER;
588  int nwords = GetFINESSENwords(n, finesse_num) - (static_cast<int>(SIZE_B2LHSLB_HEADER) + SIZE_B2LFEE_TRAILER +
589  SIZE_B2LHSLB_TRAILER);
590  unsigned short temp_crc16 = CalcCRC16LittleEndian(0xffff, buf, nwords);
591 
592  //
593  // Compare CRC16 with B2LCRC16
594  //
595  buf = GetFINESSEBuffer(n, finesse_num) + GetFINESSENwords(n, finesse_num)
596  - ((SIZE_B2LFEE_TRAILER - POS_CHKSUM_B2LFEE) + SIZE_B2LHSLB_TRAILER) ;
597 
598  if ((unsigned short)(*buf & 0xFFFF) != temp_crc16) {
599  char err_buf[500];
600  char hostname[128];
601  GetNodeName(n, hostname, sizeof(hostname));
602  PrintData(GetBuffer(n), *(GetBuffer(n) + tmp_header.POS_NWORDS));
603  printf("[FATAL] %s ch=%d : ERROR_EVENT : PRE CRC16 error : slot %c : B2LCRC16 %x Calculated CRC16 %x : Nwords of FINESSE buf %d\n",
604  hostname, finesse_num,
605  65 + finesse_num, *buf, temp_crc16, GetFINESSENwords(n, finesse_num));
606  int* temp_buf = GetFINESSEBuffer(n, finesse_num);
607  for (int k = 0; k < GetFINESSENwords(n, finesse_num); k++) {
608  printf("%.8x ", temp_buf[ k ]);
609  if ((k + 1) % 10 == 0) {
610  printf("\n");
611  }
612  }
613  printf("\n");
614  fflush(stdout);
615  sprintf(err_buf,
616  "[FATAL] %s ch=%d : ERROR_EVENT : slot %c : B2LCRC16 (%.4x) differs from one ( %.4x) calculated by PreRawCOPPERfromat class. Exiting...\n %s %s %d\n",
617  hostname, finesse_num,
618  65 + finesse_num, (unsigned short)(*buf & 0xFFFF), temp_crc16,
619  __FILE__, __PRETTY_FUNCTION__, __LINE__);
620  printf("%s", err_buf); fflush(stdout);
621  B2FATAL(err_buf); // to reduce multiple error messages
622  }
623  return 1;
624 
625 }
626 
627 int* PreRawCOPPERFormat_latest::PackDetectorBuf(int* /*packed_buf_nwords*/,
628  int* /*detector_buf_1st*/, int /*nwords_1st*/,
629  int* /*detector_buf_2nd*/, int /*nwords_2nd*/,
630  int* /*detector_buf_3rd*/, int /*nwords_3rd*/,
631  int* /*detector_buf_4th*/, int /*nwords_4th*/,
632  RawCOPPERPackerInfo rawcpr_info)
633 {
634  char err_buf[500];
635  sprintf(err_buf, "[FATAL] This function is not supported. (%u) Exiting...: \n%s %s %d\n",
636  rawcpr_info.eve_num,
637  __FILE__, __PRETTY_FUNCTION__, __LINE__);
638  printf("[DEBUG] %s\n", err_buf);
639  B2FATAL(err_buf);
640  return NULL;
641 }
642 
643 int* PreRawCOPPERFormat_latest::PackDetectorBuf(int* packed_buf_nwords,
644  int* const(&detector_buf_ch)[MAX_PCIE40_CH],
645  int const(&nwords_ch)[MAX_PCIE40_CH],
646  RawCOPPERPackerInfo rawcpr_info)
647 {
648  int* packed_buf = NULL;
649  int poswords_to = 0;
650 
651  // calculate the event length
652  int length_nwords = tmp_header.GetHdrNwords() + SIZE_COPPER_HEADER + SIZE_COPPER_TRAILER + tmp_trailer.GetTrlNwords();
653 
654  for (int i = 0; i < MAX_PCIE40_CH; i++) {
655  if (detector_buf_ch[ i ] == NULL || nwords_ch[ i ] <= 0) continue; // for an empty FINESSE slot
656  length_nwords += nwords_ch[ i ];
657  length_nwords += static_cast<int>(SIZE_B2LHSLB_HEADER) + SIZE_B2LFEE_HEADER + SIZE_B2LFEE_TRAILER + SIZE_B2LHSLB_TRAILER;
658  }
659 
660  // allocate buffer
661  packed_buf = new int[ length_nwords ];
662  memset(packed_buf, 0, sizeof(int) * length_nwords);
663 
664  //
665  // Fill RawHeader
666  //
667  tmp_header.SetBuffer(packed_buf);
668 
669  packed_buf[ tmp_header.POS_NWORDS ] = length_nwords; // total length
670  packed_buf[ tmp_header.POS_VERSION_HDRNWORDS ] = 0x7f7f8000
671  | ((DATA_FORMAT_VERSION << tmp_header.FORMAT_VERSION_SHIFT) & tmp_header.FORMAT_VERSION__MASK)
672  | tmp_header.RAWHEADER_NWORDS; // ver.#, header length
673  packed_buf[ tmp_header.POS_EXP_RUN_NO ] = (rawcpr_info.exp_num << tmp_header.EXP_SHIFT)
674  | (rawcpr_info.run_subrun_num & 0x003FFFFF); // exp. and run #
675  packed_buf[ tmp_header.POS_EVE_NO ] = rawcpr_info.eve_num; // eve #
676  packed_buf[ tmp_header.POS_TTCTIME_TRGTYPE ] = (rawcpr_info.tt_ctime & 0x7FFFFFF) << 4; // tt_ctime
677  packed_buf[ tmp_header.POS_TTUTIME ] = rawcpr_info.tt_utime; // tt_utime
678  packed_buf[ tmp_header.POS_NODE_ID ] = rawcpr_info.node_id; // node ID
679 
680  // fill the positions of finesse buffers
681  int ch = 0;
682  packed_buf[ tmp_header.POS_CH_POS_TABLE + ch ] = tmp_header.RAWHEADER_NWORDS;
683  for (int i = 1; i < MAX_PCIE40_CH; i++) {
684  ch = i;
685  if (nwords_ch[ ch - 1 ] == 0) {
686  packed_buf[ tmp_header.POS_CH_POS_TABLE + ch ] = packed_buf[ tmp_header.POS_CH_POS_TABLE + (ch - 1) ];
687  } else {
688  packed_buf[ tmp_header.POS_CH_POS_TABLE + ch ] = packed_buf[ tmp_header.POS_CH_POS_TABLE + (ch - 1) ] +
689  nwords_ch[ ch - 1 ] + SIZE_B2LHSLB_HEADER + SIZE_B2LFEE_HEADER + SIZE_B2LFEE_TRAILER + SIZE_B2LHSLB_TRAILER;
690  }
691  }
692  poswords_to += tmp_header.GetHdrNwords();
693 
694  // Fill FINESSE buffer
695  for (int i = 0; i < MAX_PCIE40_CH; i++) {
696  if (detector_buf_ch[ i ] == NULL || nwords_ch[ i ] <= 0) continue; // for an empty FINESSE slot
697 
698  // Fill b2link HSLB header
699  packed_buf[ poswords_to + POS_MAGIC_B2LHSLB ] = 0xffaa0000 | (0xffff & rawcpr_info.eve_num);
700  poswords_to += SIZE_B2LHSLB_HEADER;
701  int* crc16_start = &(packed_buf[ poswords_to ]);
702 
703  // Fill b2link FEE header
704  packed_buf[ poswords_to + POS_TT_CTIME_TYPE ] = (rawcpr_info.tt_ctime & 0x7FFFFFF) << 4;
705  unsigned int temp_ctime_type = packed_buf[ poswords_to + POS_TT_CTIME_TYPE ];
706  packed_buf[ poswords_to + POS_TT_TAG ] = rawcpr_info.eve_num;
707  packed_buf[ poswords_to + POS_TT_UTIME ] = rawcpr_info.tt_utime;
708  packed_buf[ poswords_to + POS_EXP_RUN ] = (rawcpr_info.exp_num << tmp_header.EXP_SHIFT) | (rawcpr_info.run_subrun_num &
709  0x003FFFFF); // exp. and run #
710  packed_buf[ poswords_to + POS_B2L_CTIME ] = (rawcpr_info.b2l_ctime & 0x7FFFFFF) << 4;
711  poswords_to += SIZE_B2LFEE_HEADER;
712 
713  // copy the 1st Detector Buffer
714  memcpy(packed_buf + poswords_to, detector_buf_ch[ i ], nwords_ch[ i ]*sizeof(int));
715  poswords_to += nwords_ch[ i ];
716 
717  // Fill b2link b2tt-tag trailer
718  packed_buf[ poswords_to + POS_TT_CTIME_B2LFEE ] = temp_ctime_type;
719 
720  // Fill b2link FEE trailer
721  unsigned short crc16 = CalcCRC16LittleEndian(0xffff, crc16_start, nwords_ch[ i ] + SIZE_B2LFEE_HEADER);
722  packed_buf[ poswords_to + POS_CHKSUM_B2LFEE ] = ((0xffff & rawcpr_info.eve_num) << 16) | (crc16 & 0xffff);
723  poswords_to += SIZE_B2LFEE_TRAILER;
724 
725  // Fill b2link HSLB trailer
726  packed_buf[ poswords_to + POS_CHKSUM_B2LHSLB ] = 0xff550000;
727  poswords_to += SIZE_B2LHSLB_TRAILER;
728  }
729 
730  // Calculate RawCOPPER checksum and fill RawTrailer
731  unsigned int chksum = 0;
732  for (int i = 0; i < poswords_to; i++) {
733  chksum ^= packed_buf[ i ];
734  }
735  packed_buf[ poswords_to + tmp_trailer.POS_CHKSUM ] = chksum;
736 
737  packed_buf[ poswords_to + tmp_trailer.POS_TERM_WORD ] = tmp_trailer.MAGIC_WORD_TERM_TRAILER;
738  poswords_to += tmp_trailer.GetTrlNwords();
739 
740  *packed_buf_nwords = poswords_to;
741  return packed_buf;
742 }
743 
744 
Belle2::PreRawCOPPERFormat_latest
The Raw COPPER class ver.1 ( the latest version since May, 2014 ) This class stores data received by ...
Definition: PreRawCOPPERFormat_latest.h:30
Belle2::PreRawCOPPERFormat_latest::CalcReducedNwords
int CalcReducedNwords(int n)
calculate reduced data size
Definition: PreRawCOPPERFormat_latest.cc:536
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
The RawDataBlockFormat class Format information for rawdata handling.
Definition: RawDataBlockFormat.h:25
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::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::GetNumEvents
virtual int GetNumEvents()
get # of events in m_buffer
Definition: RawDataBlockFormat.h:55
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
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17