Belle II Software  release-05-01-25
DeSerializerFILE.cc
1 //+
2 // File : DeSerializerPC.cc
3 // Description : Module to read COPPER FIFO and store it to DataStore
4 //
5 // Author : Satoru Yamada Itoh, IPNS, KEK
6 // Date : 2 - Aug - 2013
7 //-
8 
9 #include <daq/rawdata/modules/DeSerializerFILE.h>
10 #include <rawdata/dataobjects/PreRawCOPPERFormat_latest.h>
11 #include <rawdata/dataobjects/RawFTSW.h>
12 
13 using namespace std;
14 using namespace Belle2;
15 
16 //#define NO_DATA_CHECK
17 //#define WO_FIRST_EVENUM_CHECK
18 
19 //-----------------------------------------------------------------
20 // Register the Module
21 //-----------------------------------------------------------------
22 REG_MODULE(DeSerializerFILE)
23 
24 //-----------------------------------------------------------------
25 // Implementation
26 //-----------------------------------------------------------------
27 
28 DeSerializerFILEModule::DeSerializerFILEModule() : DeSerializerCOPPERModule()
29 {
30  //Set module properties
31  setDescription("Encode DataStore into RingBuffer");
32 
33  // setPropertyFlags(c_Input | c_ParallelProcessingCertified);
34  // addParam("FinesseBitFlag", finesse_bit_flag, "finnese (A,B,C,D) -> bit (0,1,2,3)", 15);
35  addParam("inputFileName", m_fname_in, "Input binary filename", string(""));
36  addParam("inputRepetitionTimes", m_repetition_max,
37  "Input repetition times to read the input file", 0);
38 
39  //Parameter definition
40  B2INFO("DeSerializerFILE: Constructor done.");
41 
42 }
43 
44 
45 DeSerializerFILEModule::~DeSerializerFILEModule()
46 {
47 }
48 
49 void DeSerializerFILEModule::fileOpen()
50 {
51  m_fp_in = fopen(m_fname_in.c_str(), "r");
52  if (!m_fp_in) {
53  char err_buf[500];
54  sprintf(err_buf, "[FATAL] Cannot open an input file(%s): %s : Exiting...\n",
55  strerror(errno), m_fname_in.c_str());
56  print_err.PrintError(err_buf, __FILE__, __PRETTY_FUNCTION__, __LINE__);
57  exit(-1);
58  }
59  return;
60 }
61 
62 void DeSerializerFILEModule::initialize()
63 {
64  B2INFO("DeSerializerFILE: initialize() started.");
65  fileOpen();
66 
67  // Initialize EvtMetaData
68  m_eventMetaDataPtr.registerInDataStore();
69 
70  memset(time_array0, 0, sizeof(time_array0));
71  memset(time_array1, 0, sizeof(time_array1));
72  memset(time_array2, 0, sizeof(time_array2));
73  memset(time_array3, 0, sizeof(time_array3));
74  memset(time_array4, 0, sizeof(time_array4));
75  memset(time_array5, 0, sizeof(time_array5));
76 
77  // Initialize Array of RawCOPPER
78  m_rawDataBlock.registerInDataStore();
79  m_rawCOPPER.registerInDataStore();
80  m_rawSVD.registerInDataStore();
81  m_rawCDC.registerInDataStore();
82  m_rawTOP.registerInDataStore();
83  m_rawARICH.registerInDataStore();
84  m_rawECL.registerInDataStore();
85  m_rawKLM.registerInDataStore();
86 
87  m_start_flag = 0;
88 
89  m_repetition_cnt = 0;
90  B2INFO("DeSerializerFILE: initialize() done.");
91 
92 }
93 
94 
95 int* DeSerializerFILEModule::readOneDataBlock(int* delete_flag, int* size_word, int* data_type)
96 {
97  *delete_flag = 1;
98  //
99  // Read 1st word( data size ) of RawDataBlock
100  //
101 
102  // int recvd_byte = RawHeader::RAWHEADER_NWORDS * sizeof(int);
103  int temp_size_word = 0;
104  int recvd_byte = 0;
105  int bytes_to_read = sizeof(int);
106 
107  int read_size = 0;
108  // if( read_size = fread( (char*)(&temp_size_word), bytes_to_read, 1, m_fp_in ) < 0 ) {
109  while (true) {
110  if ((read_size = fread((char*)(&temp_size_word), 1, bytes_to_read, m_fp_in)) != bytes_to_read) {
111  if (feof(m_fp_in)) {
112  if (m_repetition_max > m_repetition_cnt) {
113  m_repetition_cnt++;
114  fclose(m_fp_in);
115  fileOpen();
116  continue;
117  } else {
118  return 0x0;
119  }
120  }
121  char err_buf[500];
122  sprintf(err_buf, "[FATAL] Failed to read header(%s).", strerror(errno));
123  print_err.PrintError(err_buf, __FILE__, __PRETTY_FUNCTION__, __LINE__);
124  exit(-1);
125  }
126  break;
127  }
128  recvd_byte += read_size;
129 
130  int start_word = 0, stop_word = 0;
131  int* temp_buf = 0x0;
132  if (temp_size_word == 0x7fff0008) {
133  // 0x7fff0008 -> 2.1Gword. So this is too large for the length of one RawDataBlock.
134  *data_type = COPPER_DATABLOCK;
135 
136  int pos_data_length;
137 
138  pos_data_length = PreRawCOPPERFormat_latest::POS_DATA_LENGTH;
139 
140  start_word = 0;
141  stop_word = pos_data_length;
142  int* length_buf = readfromFILE(m_fp_in, pos_data_length, start_word, stop_word);
143 
144 
145  *size_word = length_buf[ pos_data_length - 1 ] +
146  PreRawCOPPERFormat_latest::SIZE_COPPER_DRIVER_HEADER + PreRawCOPPERFormat_latest::SIZE_COPPER_DRIVER_TRAILER
147  + m_pre_rawcpr.tmp_header.RAWHEADER_NWORDS + m_pre_rawcpr.tmp_trailer.RAWTRAILER_NWORDS;
148  start_word = 1 + pos_data_length + m_pre_rawcpr.tmp_header.RAWHEADER_NWORDS;
149  stop_word = *size_word - m_pre_rawcpr.tmp_trailer.RAWTRAILER_NWORDS;
150 
151  temp_buf = readfromFILE(m_fp_in, *size_word, start_word, stop_word);
152 
153 
154  temp_buf[ m_pre_rawcpr.tmp_header.RAWHEADER_NWORDS ] = 0x7fff0008;
155  memcpy((temp_buf + m_pre_rawcpr.tmp_header.RAWHEADER_NWORDS + 1),
156  length_buf, sizeof(int) * pos_data_length);
157 
158  delete length_buf;
159  } else {
160  *data_type = RAW_DATABLOCK;
161  *size_word = temp_size_word;
162  start_word = 1;
163  stop_word = *size_word;
164  temp_buf = readfromFILE(m_fp_in, *size_word, start_word, stop_word);
165  }
166  return temp_buf;
167 }
168 
169 
170 
171 int* DeSerializerFILEModule::readfromFILE(FILE* fp_in, const int size_word, const int start_word, const int stop_word)
172 {
173  //
174  // Allocate buffer if needed
175  //
176  int* temp_buf;
177  temp_buf = new int[ size_word ];
178 
179  memset(temp_buf, 0, size_word * sizeof(int));
180  temp_buf[ 0 ] = size_word;
181  int recvd_byte = start_word * sizeof(int);
182  int bytes_to_read = stop_word * sizeof(int);
183  int read_size;
184 
185  if ((read_size = fread((char*)temp_buf + recvd_byte, 1, bytes_to_read - recvd_byte, fp_in)) < 0) {
186  if (feof(fp_in)) {
187  delete[] temp_buf;
188  return 0x0;
189  }
190  char err_buf[500];
191  sprintf(err_buf, "[FATAL] Failed to read header. Exiting...");
192  print_err.PrintError(err_buf, __FILE__, __PRETTY_FUNCTION__, __LINE__);
193  exit(-1);
194  }
195  recvd_byte += read_size;
196 
197  if (bytes_to_read != recvd_byte) {
198  char err_buf[500];
199  sprintf(err_buf, "[FATAL] Read less bytes(%d) than expected(%d). Exiting...\n",
200  recvd_byte, bytes_to_read);
201  print_err.PrintError(err_buf, __FILE__, __PRETTY_FUNCTION__, __LINE__);
202  exit(-1);
203  }
204  return temp_buf;
205 }
206 
207 
208 
209 void DeSerializerFILEModule::event()
210 {
211 
212  if (m_start_flag == 0) {
213  m_start_flag = 1;
214  m_dummy_evenum = 0;
215  }
216 
217  if (m_start_flag == 0) {
218  B2INFO("DeSerializerFILE: event() started.");
219  m_start_time = getTimeSec();
220  n_basf2evt = 0;
221  m_start_flag = 1;
222  }
223 
224  // rawcprarray.create();
225  // raw_dblkarray.create();
226 
227  // RawCOPPER* temp_rawcopper;
228 
229  int first_flag = 0;
230  unsigned int prev_eve_num = 0;
231  int eof_flag = 0;
232 
233  //
234  // Update EventMetaData
235  //
236 
237  while (true) {
238  int size_word = 0;
239  int delete_flag = 0;
240  // int* temp_buf = readOneEventFromCOPPERFIFO(j, &delete_flag, &size_word);
241  int* temp_buf;
242 
243  if (m_prev_buf_flag == 1) {
244  temp_buf = m_prev_buf;
245  size_word = temp_buf[ 0 ];
246  m_prev_buf_flag = 0;
247  } else {
248  int data_type;
249  temp_buf = readOneDataBlock(&delete_flag, &size_word, &data_type);
250 
251 
252  if (temp_buf == 0x0) { // End of File
253  printf("[DEBUG] End of file\n");
254  eof_flag = 1;
255  break;
256  }
257 
258  if (data_type == COPPER_DATABLOCK) {
259 
260  RawCOPPER temp_rawcopper;
261 
262  int num_nodes = 1;
263  int num_events = 1;
264  temp_rawcopper.SetBuffer(temp_buf, size_word, 0, num_events, num_nodes);
265 
266  {
267  printf("[FATAL] Sorry. This version does not support fillNewCOPPERheader()");
268  exit(1);
269  // fillNewRawCOPPERHeader(&temp_rawcopper);
270  }
271 
272 
273  unsigned int temp_cur_evenum = 0, temp_cur_copper_ctr = 0;
274 
275  try {
276  temp_rawcopper.CheckData(0,
277  m_dummy_evenum - 2, &temp_cur_evenum,
278  m_dummy_evenum - 2, &temp_cur_copper_ctr,
279  m_prev_exprunsubrun_no, &m_exprunsubrun_no);
280 
281  } catch (string err_str) {
282  print_err.PrintError(m_shmflag, &g_status, err_str);
283  exit(1);
284  }
285  m_prev_run_no = m_run_no; // The place of this update depends on # of nodes
286  }
287 
288 
289  }
290 
291  //
292  // Check Event #
293  //
294  RawDataBlock temp_rawdblk;
295  int num_nodes = 1;
296  int num_events = 1;
297 
298  temp_rawdblk.SetBuffer(temp_buf, size_word, 0, num_nodes, num_events);
299  int block_num = 0;
300 
301  unsigned int eve_num;
302  int subsysid = 0;
303 
304  if (temp_rawdblk.CheckFTSWID(block_num)) {
305  RawFTSW temp_raw_ftsw;
306  temp_raw_ftsw.SetBuffer(temp_buf, size_word, 0, num_nodes, num_events);
307  eve_num = temp_raw_ftsw.GetEveNo(block_num);
308  } else {
309  RawCOPPER temp_raw_copper;
310  temp_raw_copper.SetBuffer(temp_buf, size_word, 0, num_nodes, num_events);
311  eve_num = temp_raw_copper.GetEveNo(block_num);
312  subsysid = temp_raw_copper.GetNodeID(block_num);
313  }
314 
315  if (eve_num != prev_eve_num && first_flag != 0) {
316  m_prev_buf_flag = 1;
317  m_prev_buf = temp_buf;
318  break;
319  }
320  prev_eve_num = eve_num;
321 
322  if (temp_rawdblk.CheckFTSWID(block_num)) {
323  StoreArray<RawFTSW> ary;
324  (ary.appendNew())->SetBuffer(temp_buf, size_word, 1, num_nodes, num_events);
325  } else {
326 
327  //
328  // Switch to each detector and register RawXXX
329  //
330  // if (subsysid == CDC_ID) {
331  // StoreArray<RawCDC> ary;
332  // (ary.appendNew())->SetBuffer(temp_buf, size_word, 1, 1, 1);
333  // } else if (subsysid == SVD_ID) {
334  StoreArray<RawSVD> ary;
335  (ary.appendNew())->SetBuffer(temp_buf, size_word, 1, 1, 1);
336  // } else if (subsysid == ECL_ID) {
337  // StoreArray<RawECL> ary;
338  // (ary.appendNew())->SetBuffer(temp_buf, size_word, 1, 1, 1);
339  // } else if (subsysid == TOP_ID) {
340  // StoreArray<RawTOP> ary;
341  // (ary.appendNew())->SetBuffer(temp_buf, size_word, 1, 1, 1);
342  // } else if (subsysid == ARICH_ID) {
343  // StoreArray<RawARICH> ary;
344  // (ary.appendNew())->SetBuffer(temp_buf, size_word, 1, 1, 1);
345  // } else if (subsysid == KLM_ID) {
346  // StoreArray<RawKLM> ary;
347  // (ary.appendNew())->SetBuffer(temp_buf, size_word, 1, 1, 1);
348  // } else {
349 // StoreArray<RawCOPPER> ary;
350 // (ary.appendNew())->SetBuffer(temp_buf, size_word, 1, 1, 1);
351  // }
352 
353 
354  }
355 
356  m_totbytes += size_word * sizeof(int);
357 
358  first_flag = 1;
359  }
360 
361 
362  m_eventMetaDataPtr.create();
363  m_eventMetaDataPtr->setExperiment(0);
364  m_eventMetaDataPtr->setRun(0);
365  m_eventMetaDataPtr->setEvent(prev_eve_num);
366  if (eof_flag == 1) {
367  m_eventMetaDataPtr->setEndOfData();
368  }
369 
370  if (n_basf2evt % 100 == 0) {
371  printf("[DEBUG] Processing Evt # %d...\n", prev_eve_num);
372  }
373 
374  n_basf2evt++;
375  return;
376 }
377 
Belle2::RawCOPPER
The Raw COPPER class This class stores data received by COPPER via belle2linkt Data from all detector...
Definition: RawCOPPER.h:50
Belle2::StoreArray::appendNew
T * appendNew()
Construct a new T object at the end of the array.
Definition: StoreArray.h:256
Belle2::RawDataBlock::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: RawDataBlock.cc:35
Belle2::DeSerializerCOPPERModule
A class definition of an input module for Sequential ROOT I/O.
Definition: DeSerializerCOPPER.h:31
REG_MODULE
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition: Module.h:652
Belle2::RawDataBlock::CheckFTSWID
virtual int CheckFTSWID(int n)
get FTSW ID to check whether this data block is FTSW data or not
Definition: RawDataBlock.h:101
Belle2::RawCOPPER::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)
check data contents
Definition: RawCOPPER.h:685
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::RawCOPPER::GetEveNo
unsigned int GetEveNo(int n)
get subrun #(8bit)
Definition: RawCOPPER.h:376
Belle2::RawCOPPER::GetNodeID
unsigned int GetNodeID(int n)
get node-ID from data
Definition: RawCOPPER.h:383
Belle2::RawCOPPER::SetBuffer
void SetBuffer(int *bufin, int nwords, int delete_flag, int num_events, int num_nodes) OVERRIDE_CPP17
set buffer ( delete_flag : m_buffer is freeed( = 0 )/ not freeed( = 1 ) in Destructer )
Definition: RawCOPPER.cc:132
Belle2::RawFTSW::GetEveNo
unsigned int GetEveNo(int n)
Get event #.
Definition: RawFTSW.h:64
Belle2::StoreArray
Accessor to arrays stored in the data store.
Definition: ECLMatchingPerformanceExpertModule.h:33
Belle2::RawFTSW::SetBuffer
void SetBuffer(int *bufin, int nwords, int delete_flag, int num_events, int num_nodes) OVERRIDE_CPP17
set buffer ( delete_flag : m_buffer is freeed( = 0 )/ not freeed( = 1 ) in Destructer )
Definition: RawFTSW.cc:107
Belle2::DeSerializerFILEModule
A class definition of an input module for Sequential ROOT I/O.
Definition: DeSerializerFILE.h:29
Belle2::RawDataBlock
The RawDataBlock class Base class for rawdata handling.
Definition: RawDataBlock.h:27
Belle2::StoreArray::create
bool create(bool replace=false)
Creating StoreArrays is unnecessary, only used internally.
Definition: StoreArray.h:339
Belle2::RawFTSW
The Raw FTSW class.
Definition: RawFTSW.h:30