Belle II Software  release-08-01-10
PostRawCOPPERFormat_v2.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/PostRawCOPPERFormat_v2.h>
10 
11 
12 using namespace std;
13 using namespace Belle2;
14 
15 //#define DESY
16 //#define NO_ERROR_STOP
17 //ClassImp(PostRawCOPPERFormat_v2);
18 
19 PostRawCOPPERFormat_v2::PostRawCOPPERFormat_v2()
20 {
21 }
22 
23 PostRawCOPPERFormat_v2::~PostRawCOPPERFormat_v2()
24 {
25 }
26 
27 
28 int PostRawCOPPERFormat_v2::GetDetectorNwords(int n, int finesse_num)
29 {
30  int nwords = 0;
31  if (GetFINESSENwords(n, finesse_num) > 0) {
32  nwords = GetFINESSENwords(n, finesse_num)
33  - (static_cast<int>(SIZE_B2LHSLB_HEADER) + SIZE_B2LHSLB_TRAILER + SIZE_B2LFEE_HEADER + SIZE_B2LFEE_TRAILER);
34  }
35  return nwords;
36 }
37 
38 
39 unsigned int PostRawCOPPERFormat_v2::CalcDriverChkSum(int n)
40 {
41  char err_buf[500];
42  sprintf(err_buf, "[FATAL] This function is not supported.(block %d) Exiting...: \n%s %s %d\n",
43  n, __FILE__, __PRETTY_FUNCTION__, __LINE__);
44  printf("[DEBUG] %s\n", err_buf);
45  B2FATAL(err_buf);
46  return 0;
47 }
48 
49 
50 int PostRawCOPPERFormat_v2::GetFINESSENwords(int n, int finesse_num)
51 {
52  int pos_nwords_0, pos_nwords_1;
53  int nwords = 0;
54  switch (finesse_num) {
55  case 0 :
56  pos_nwords_0 = GetBufferPos(n) + tmp_header.POS_OFFSET_1ST_FINESSE;
57  pos_nwords_1 = GetBufferPos(n) + tmp_header.POS_OFFSET_2ND_FINESSE;
58  nwords = m_buffer[ pos_nwords_1 ] - m_buffer[ pos_nwords_0 ];
59  break;
60  case 1 :
61  pos_nwords_0 = GetBufferPos(n) + tmp_header.POS_OFFSET_2ND_FINESSE;
62  pos_nwords_1 = GetBufferPos(n) + tmp_header.POS_OFFSET_3RD_FINESSE;
63  nwords = m_buffer[ pos_nwords_1 ] - m_buffer[ pos_nwords_0 ];
64  break;
65  case 2 :
66  pos_nwords_0 = GetBufferPos(n) + tmp_header.POS_OFFSET_3RD_FINESSE;
67  pos_nwords_1 = GetBufferPos(n) + tmp_header.POS_OFFSET_4TH_FINESSE;
68  nwords = m_buffer[ pos_nwords_1 ] - m_buffer[ pos_nwords_0 ];
69  break;
70  case 3 :
71  pos_nwords_0 = GetBufferPos(n) + tmp_header.POS_OFFSET_4TH_FINESSE;
72  {
73  int nwords_1 = GetBlockNwords(n)
74  - SIZE_COPPER_DRIVER_TRAILER
75  - tmp_trailer.GetTrlNwords();
76  nwords = nwords_1 - m_buffer[ pos_nwords_0 ];
77  }
78  break;
79  default :
80  char err_buf[500];
81  sprintf(err_buf, "[FATAL] Invalid finesse # : %s %s %d\n",
82  __FILE__, __PRETTY_FUNCTION__, __LINE__);
83  printf("[DEBUG] %s\n", err_buf);
84  B2FATAL(err_buf);
85  }
86 
87  if (nwords < 0 || nwords > 1e6) {
88  char err_buf[500];
89  char hostname[128];
90  GetNodeName(n, hostname, sizeof(hostname));
91  sprintf(err_buf, "[FATAL] %s ch=%d : ERROR_EVENT : # of words is strange. %d : eve 0x%x exp %d run %d sub %d\n %s %s %d\n",
92  hostname, finesse_num,
93  nwords,
94  GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n),
95  __FILE__, __PRETTY_FUNCTION__, __LINE__);
96  printf("[DEBUG] %s\n", err_buf);
97  B2FATAL(err_buf);
98  }
99 
100  return nwords;
101 
102 }
103 
104 
105 
106 
107 unsigned int PostRawCOPPERFormat_v2::GetB2LFEE32bitEventNumber(int n)
108 {
109  char err_buf[500];
110  char hostname[128];
111  GetNodeName(n, hostname, sizeof(hostname));
112  sprintf(err_buf,
113  "[FATAL] %s ch=%d : ERROR_EVENT : No event # in B2LFEE header. (block %d) Exiting... : eve 0x%x exp %d run %d sub %d\n%s %s %d\n",
114  hostname, -1,
115  n,
116  GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n),
117  __FILE__, __PRETTY_FUNCTION__, __LINE__);
118  printf("[DEBUG] %s\n", err_buf);
119  B2FATAL(err_buf);
120  return 0;
121 }
122 
123 
124 
125 void PostRawCOPPERFormat_v2::CheckData(int n,
126  unsigned int prev_evenum, unsigned int* cur_evenum_rawcprhdr,
127  unsigned int prev_copper_ctr, unsigned int* cur_copper_ctr,
128  unsigned int prev_exprunsubrun_no, unsigned int* cur_exprunsubrun_no)
129 {
130  char err_buf[500];
131  int err_flag = 0;
132 
133  //
134  // Check incrementation of event #
135  //
136  *cur_evenum_rawcprhdr = GetEveNo(n);
137  *cur_exprunsubrun_no = GetExpRunSubrun(n);
138 
139  if (prev_exprunsubrun_no == *cur_exprunsubrun_no) {
140  if ((unsigned int)(prev_evenum + 1) != *cur_evenum_rawcprhdr) {
141  sprintf(err_buf, "CORRUPTED DATA: Event # jump : i %d prev 0x%x cur 0x%x : Exiting...\n%s %s %d\n",
142  n, prev_evenum, *cur_evenum_rawcprhdr,
143  __FILE__, __PRETTY_FUNCTION__, __LINE__);
144  err_flag = 1;
145  }
146  }
147 
148 
149  //
150  // Check checksum calculated by DeSerializerCOPPER()
151  //
152  tmp_trailer.SetBuffer(GetRawTrlBufPtr(n));
153  unsigned int xor_chksum = CalcXORChecksum(GetBuffer(n), GetBlockNwords(n) - tmp_trailer.GetTrlNwords());
154  if (tmp_trailer.GetChksum() != xor_chksum) {
155  char hostname[128];
156  GetNodeName(n, hostname, sizeof(hostname));
157  sprintf(err_buf,
158  "[FATAL] %s ch=%d : ERROR_EVENT : 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",
159  hostname, -1,
160  n, GetBlockNwords(n), *cur_evenum_rawcprhdr, tmp_trailer.GetChksum(), xor_chksum,
161  GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n),
162  __FILE__, __PRETTY_FUNCTION__, __LINE__);
163  err_flag = 1;
164  }
165 
166 
167  if (err_flag == 1) {
168  printf("[DEBUG] %s\n", err_buf);
169  printf("[DEBUG] ========== dump a data blcok : block # %d==========\n", n);
170  PrintData(GetBuffer(n), GetBlockNwords(n));
171  printf("Print out variables to reduce unused-variables-warnings : %u %u\n", prev_copper_ctr, *cur_copper_ctr);
172  B2FATAL(err_buf);
173  }
174 
175  return;
176 
177 }
178 
179 bool PostRawCOPPERFormat_v2::CheckCOPPERMagic(int n)
180 {
181  char err_buf[500];
182  char hostname[128];
183  GetNodeName(n, hostname, sizeof(hostname));
184  sprintf(err_buf,
185  "[FATAL] %s ch=%d : ERROR_EVENT : No magic word # in COPPER header (block %d). Exiting...: eve 0x%x exp %d run %d sub %d\n%s %s %d\n",
186  hostname, -1,
187  n,
188  GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n),
189  __FILE__, __PRETTY_FUNCTION__, __LINE__);
190  printf("[DEBUG] %s\n", err_buf);
191  B2FATAL(err_buf);
192  return false;
193 }
194 
195 void PostRawCOPPERFormat_v2::CheckUtimeCtimeTRGType(int n)
196 {
197  char err_buf[500];
198  sprintf(err_buf, "[FATAL] This function is not supported (block %d). Exiting...\n%s %s %d\n",
199  n, __FILE__, __PRETTY_FUNCTION__, __LINE__);
200  printf("[DEBUG] %s\n", err_buf);
201  B2FATAL(err_buf);
202 }
203 
204 unsigned int PostRawCOPPERFormat_v2::FillTopBlockRawHeader(unsigned int m_node_id, unsigned int prev_eve32,
205  unsigned int prev_exprunsubrun_no, unsigned int* cur_exprunsubrun_no)
206 
207 {
208  char err_buf[500];
209  sprintf(err_buf, "[FATAL] This function should be called by PrePostRawCOPPERFormat_***. Exiting...\n %s %s %d\n",
210  __FILE__, __PRETTY_FUNCTION__, __LINE__);
211  printf("Print out variables to reduce unused-variables-warnings : %u %u %u %u\n",
212  m_node_id, prev_eve32, prev_exprunsubrun_no, *cur_exprunsubrun_no);
213  printf("[DEBUG] %s\n", err_buf);
214  B2FATAL(err_buf);
215 }
216 
217 
218 int PostRawCOPPERFormat_v2::CheckB2LHSLBMagicWords(int* finesse_buf, int finesse_nwords)
219 {
220  char err_buf[500];
221  sprintf(err_buf, "[FATAL] This function should be called by PrePostRawCOPPERFormat_***. Exiting...\n %s %s %d\n",
222  __FILE__, __PRETTY_FUNCTION__, __LINE__);
223  printf("Print out variables to reduce unused-variables-warnings : %p %d\n", finesse_buf, finesse_nwords);
224  printf("[DEBUG] %s\n", err_buf);
225  B2FATAL(err_buf);
226 }
227 
228 int PostRawCOPPERFormat_v2::CheckCRC16(int n, int finesse_num)
229 {
230 
231  //
232  // Calculate CRC16
233  //
234  int finesse_nwords = GetFINESSENwords(n, finesse_num);
235  if (finesse_nwords <= 0) {
236  char err_buf[500];
237  char hostname[128];
238  GetNodeName(n, hostname, sizeof(hostname));
239  sprintf(err_buf,
240  "[FATAL] %s ch=%d : ERROR_EVENT : The specified finesse(%c) seems to be empty(nwords = %d). Cannot calculate CRC16. Exiting...: eve 0x%x exp %d run %d sub %d\n %s %s %d\n",
241  hostname, finesse_num,
242  65 + finesse_num, finesse_nwords,
243  GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n),
244  __FILE__, __PRETTY_FUNCTION__, __LINE__);
245  printf("%s", err_buf); fflush(stdout);
246  B2FATAL(err_buf);
247  }
248 
249  int* copper_buf = GetBuffer(n);
250 
251 
252  unsigned short temp_crc16 = CalcCRC16LittleEndian(0xffff, &(copper_buf[ tmp_header.POS_TTCTIME_TRGTYPE ]), 1);
253  temp_crc16 = CalcCRC16LittleEndian(temp_crc16, &(copper_buf[ tmp_header.POS_EVE_NO ]), 1);
254  temp_crc16 = CalcCRC16LittleEndian(temp_crc16, &(copper_buf[ tmp_header.POS_TTUTIME ]), 1);
255  temp_crc16 = CalcCRC16LittleEndian(temp_crc16, &(copper_buf[ tmp_header.POS_EXP_RUN_NO ]), 1);
256  int* buf = GetFINESSEBuffer(n, finesse_num) + SIZE_B2LHSLB_HEADER + POS_B2L_CTIME;
257  int pos_nwords = finesse_nwords - (static_cast<int>(SIZE_B2LHSLB_HEADER) + POS_B2L_CTIME + SIZE_B2LFEE_TRAILER +
258  SIZE_B2LHSLB_TRAILER);
259  temp_crc16 = CalcCRC16LittleEndian(temp_crc16, buf, pos_nwords);
260 
261  //
262  // Compare CRC16 with B2LCRC16
263  //
264  buf = GetFINESSEBuffer(n, finesse_num) + GetFINESSENwords(n,
265  finesse_num) - ((SIZE_B2LFEE_TRAILER - POS_B2LFEE_ERRCNT_CRC16) + SIZE_B2LHSLB_TRAILER) ;
266 
267  if (GetEveNo(n) % 100000 == 0) {
268  printf("#### PostRawCOPPER : Eve %.8x block %d finesse %d B2LCRC16 %.8x calculated CRC16 %.8x\n", GetEveNo(n), n, finesse_num,
269  *buf, temp_crc16);
270  }
271 
272  // if ( false ) {
273  if ((unsigned short)(*buf & 0xFFFF) != temp_crc16) {
274 
275  // dump an event
276  int copper_nwords = copper_buf[ tmp_header.POS_NWORDS ];
277  PrintData(copper_buf, copper_nwords);
278  // Check whether packet-CRC error has occcured or not.
279  if (copper_buf[ tmp_header.POS_TRUNC_MASK_DATATYPE ] & tmp_header.B2LINK_PACKET_CRC_ERROR) {
280  //
281  // Do not stop data
282  //
283  char err_buf[600];
284  char hostname[128];
285  GetNodeName(n, hostname, sizeof(hostname));
286 
287  if ((GetNodeID(n) & DETECTOR_MASK) == ARICH_ID) {
288  sprintf(err_buf,
289  "[WARNING] %s ch=%d : ARICH : POST B2link event CRC16 error with B2link Packet CRC error. data(%x) calc(%x) fns nwords %d type 0x%.8x : This error is ignored and the error event will be recorded in .sroot file acording to request from ARICH group: slot%c eve 0x%x exp %d run %d sub %d\n%s %s %d\n",
290  hostname, finesse_num,
291  *buf, temp_crc16, GetFINESSENwords(n, finesse_num), copper_buf[ tmp_header.POS_TRUNC_MASK_DATATYPE ],
292  65 + finesse_num, GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n),
293  __FILE__, __PRETTY_FUNCTION__, __LINE__);
294  printf("%s", err_buf); fflush(stdout);
295  PrintData(GetFINESSEBuffer(n, finesse_num), GetFINESSENwords(n, finesse_num));
296  } else {
297  sprintf(err_buf,
298  "[FATAL] %s ch=%d : ERROR_EVENT : POST B2link event CRC16 error with B2link Packet CRC error. data(%x) calc(%x) fns nwords %d type 0x%.8x : slot%c eve 0x%x exp %d run %d sub %d\n%s %s %d\n",
299  hostname, finesse_num,
300  *buf, temp_crc16, GetFINESSENwords(n, finesse_num), copper_buf[ tmp_header.POS_TRUNC_MASK_DATATYPE ],
301  65 + finesse_num, GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n),
302  __FILE__, __PRETTY_FUNCTION__, __LINE__);
303  printf("%s", err_buf); fflush(stdout);
304  PrintData(GetFINESSEBuffer(n, finesse_num), GetFINESSENwords(n, finesse_num));
305 #ifndef NO_ERROR_STOP
306  B2FATAL(err_buf);
307 #endif
308  }
309 
310 
311 
312  } else {
313  //
314  // Stop taking data
315  //
316  char err_buf[500];
317  char hostname[128];
318  GetNodeName(n, hostname, sizeof(hostname));
319  sprintf(err_buf,
320  "[FATAL] %s ch=%d : ERROR_EVENT : POST B2link event CRC16 error without B2link Packet CRC error. data(%x) calc(%x) fns nwords %d type 0x%.8x: slot%c eve 0x%x exp %d run %d sub %d\n%s %s %d\n",
321  hostname, finesse_num,
322  *buf, temp_crc16, GetFINESSENwords(n, finesse_num), copper_buf[ tmp_header.POS_TRUNC_MASK_DATATYPE ],
323  65 + finesse_num, GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n),
324  __FILE__, __PRETTY_FUNCTION__, __LINE__);
325  printf("%s", err_buf); fflush(stdout);
326  PrintData(GetFINESSEBuffer(n, finesse_num), GetFINESSENwords(n, finesse_num));
327 #ifndef NO_ERROR_STOP
328  B2FATAL(err_buf);
329 #endif
330  }
331  // Modify XOR checksum due to adding a bit flag
332  copper_buf[ copper_nwords - tmp_trailer.RAWTRAILER_NWORDS + tmp_trailer.POS_CHKSUM ]
333  ^= copper_buf[ tmp_header.POS_TRUNC_MASK_DATATYPE ];
334  copper_buf[ tmp_header.POS_TRUNC_MASK_DATATYPE ] |= tmp_header.B2LINK_EVENT_CRC_ERROR;
335  copper_buf[ copper_nwords - tmp_trailer.RAWTRAILER_NWORDS + tmp_trailer.POS_CHKSUM ]
336  ^= copper_buf[ tmp_header.POS_TRUNC_MASK_DATATYPE ];
337  }
338 
339  return 1;
340 
341 
342 }
343 
344 
345 int* PostRawCOPPERFormat_v2::PackDetectorBuf(int* packed_buf_nwords,
346  int* detector_buf_1st, int nwords_1st,
347  int* detector_buf_2nd, int nwords_2nd,
348  int* detector_buf_3rd, int nwords_3rd,
349  int* detector_buf_4th, int nwords_4th,
350  RawCOPPERPackerInfo rawcpr_info)
351 {
352  int* packed_buf = NULL;
353 
354  int poswords_to = 0;
355  int* detector_buf[ 4 ] = { detector_buf_1st, detector_buf_2nd, detector_buf_3rd, detector_buf_4th };
356  const int nwords[ 4 ] = { nwords_1st, nwords_2nd, nwords_3rd, nwords_4th };
357 
358  // calculate the event length
359  int length_nwords = tmp_header.GetHdrNwords() + SIZE_COPPER_HEADER + SIZE_COPPER_TRAILER + tmp_trailer.GetTrlNwords();
360 
361  for (int i = 0; i < 4; i++) {
362  if (detector_buf[ i ] == NULL || nwords[ i ] <= 0) continue; // for an empty FINESSE slot
363  length_nwords += nwords[ i ];
364  length_nwords += static_cast<int>(SIZE_B2LHSLB_HEADER) + SIZE_B2LFEE_HEADER
365  + SIZE_B2LFEE_TRAILER + SIZE_B2LHSLB_TRAILER;
366  }
367 
368  // allocate buffer
369  packed_buf = new int[ length_nwords ];
370  memset(packed_buf, 0, sizeof(int) * length_nwords);
371 
372  //
373  // Fill RawHeader
374  //
375  tmp_header.SetBuffer(packed_buf);
376 
377  packed_buf[ tmp_header.POS_NWORDS ] = length_nwords; // total length
378  packed_buf[ tmp_header.POS_VERSION_HDRNWORDS ] =
379  0x7f7f0000
380  | ((DATA_FORMAT_VERSION << tmp_header.FORMAT_VERSION_SHIFT) & tmp_header.FORMAT_VERSION__MASK)
381  | tmp_header.RAWHEADER_NWORDS; // ver.#, header length
382  packed_buf[ tmp_header.POS_EXP_RUN_NO ] = (rawcpr_info.exp_num << 22)
383  | (rawcpr_info.run_subrun_num & 0x003FFFFF); // exp. and run #
384  packed_buf[ tmp_header.POS_EVE_NO ] = rawcpr_info.eve_num; // eve #
385  packed_buf[ tmp_header.POS_TTCTIME_TRGTYPE ] = (rawcpr_info.tt_ctime & 0x7FFFFFF) << 4; // tt_ctime
386  packed_buf[ tmp_header.POS_TTUTIME ] = rawcpr_info.tt_utime; // tt_utime
387  packed_buf[ tmp_header.POS_NODE_ID ] = rawcpr_info.node_id; // node ID
388 
389  // fill the positions of finesse buffers
390  packed_buf[ tmp_header.POS_OFFSET_1ST_FINESSE ] = static_cast<int>(tmp_header.RAWHEADER_NWORDS) + SIZE_COPPER_HEADER;
391 
392  packed_buf[ tmp_header.POS_OFFSET_2ND_FINESSE ] = packed_buf[ tmp_header.POS_OFFSET_1ST_FINESSE ];
393  if (nwords[ 0 ] > 0) {
394  packed_buf[ tmp_header.POS_OFFSET_2ND_FINESSE ] +=
395  nwords[ 0 ] + SIZE_B2LHSLB_HEADER + SIZE_B2LFEE_HEADER + SIZE_B2LFEE_TRAILER + SIZE_B2LHSLB_TRAILER;
396  }
397 
398  packed_buf[ tmp_header.POS_OFFSET_3RD_FINESSE ] = packed_buf[ tmp_header.POS_OFFSET_2ND_FINESSE ];
399  if (nwords[ 1 ] > 0) {
400  packed_buf[ tmp_header.POS_OFFSET_3RD_FINESSE ] +=
401  nwords[ 1 ] + SIZE_B2LHSLB_HEADER + SIZE_B2LFEE_HEADER + SIZE_B2LFEE_TRAILER + SIZE_B2LHSLB_TRAILER;
402  }
403 
404  packed_buf[ tmp_header.POS_OFFSET_4TH_FINESSE ] = packed_buf[ tmp_header.POS_OFFSET_3RD_FINESSE ];
405  if (nwords[ 2 ] > 0) {
406  packed_buf[ tmp_header.POS_OFFSET_4TH_FINESSE ] += nwords[ 2 ] + SIZE_B2LHSLB_HEADER + SIZE_B2LFEE_HEADER + SIZE_B2LFEE_TRAILER +
407  SIZE_B2LHSLB_TRAILER;
408  }
409  poswords_to += tmp_header.GetHdrNwords();
410 
411  // Fill COPPER header
412  poswords_to += SIZE_COPPER_HEADER;
413 
414  // Fill FINESSE buffer
415  for (int i = 0; i < 4; i++) {
416 
417  if (detector_buf[ i ] == NULL || nwords[ i ] <= 0) continue; // for an empty FINESSE slot
418 
419  // Fill b2link HSLB header
420  packed_buf[ poswords_to + POS_B2LHSLB_MAGIC ] = 0xffaa0000 | (0xffff & rawcpr_info.eve_num);
421  poswords_to += SIZE_B2LHSLB_HEADER;
422 
423  // Fill b2link FEE header
424  packed_buf[ poswords_to + POS_B2L_CTIME ] = (rawcpr_info.b2l_ctime & 0x7FFFFFF) << 4;
425  poswords_to += SIZE_B2LFEE_HEADER;
426 
427  // copy the 1st Detector Buffer
428  memcpy(packed_buf + poswords_to, detector_buf[ i ], nwords[ i ]*sizeof(int));
429  poswords_to += nwords[ i ];
430 
431  // Fill b2link FEE trailer
432  unsigned int crc16 = 0;
433  packed_buf[ poswords_to + POS_B2LFEE_ERRCNT_CRC16 ] = crc16 &
434  0xffff; // Error count is stored in this buffer for ver.2 format but it is set to zero here.
435  poswords_to += SIZE_B2LFEE_TRAILER;
436 
437  // Fill b2link HSLB trailer
438  poswords_to += SIZE_B2LHSLB_TRAILER;
439 
440  }
441 
442  // Fill COPPER trailer
443  poswords_to += SIZE_COPPER_TRAILER;
444 
445  // Fill RawTrailer
446  packed_buf[ poswords_to + tmp_trailer.POS_TERM_WORD ] = tmp_trailer.MAGIC_WORD_TERM_TRAILER;
447  poswords_to += tmp_trailer.GetTrlNwords();
448 
449  *packed_buf_nwords = poswords_to;
450 
451  return packed_buf;
452 }
453 
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
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17