Belle II Software development
PXDReadRawBonnDAQ.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 <pxd/modules/pxdUnpacking/PXDReadRawBonnDAQ.h>
10#include <framework/dataobjects/EventMetaData.h>
11#include <rawdata/dataobjects/RawPXD.h>
12
13#include <boost/endian/arithmetic.hpp>
14#include <boost/crc.hpp>
15
16using namespace std;
17using namespace Belle2;
18using namespace PXD;
19
20using ulittle16_t = boost::endian::little_uint16_t;
21using ulittle32_t = boost::endian::little_uint32_t;
22using ubig16_t = boost::endian::big_uint16_t;
23using ubig32_t = boost::endian::big_uint32_t;
24
25using boost::crc_optimal;
26typedef crc_optimal<32, 0x04C11DB7, 0, 0, false, false> dhe_crc_32_type;
27
28//-----------------------------------------------------------------
29// Register the Module
30//-----------------------------------------------------------------
31REG_MODULE(PXDReadRawBonnDAQ);
32
33//-----------------------------------------------------------------
34// Implementation
35//-----------------------------------------------------------------
36
38{
39 fh = 0;
40 //Set module properties
41 setDescription("Read a BonnDAQ file and stores it as RawPXD in Data Store");
42 //setPropertyFlags(c_Input | c_ParallelProcessingCertified); // not parallel processing!
43
44 addParam("FileName", m_filename, "file name");
45 addParam("SubRunNr", m_subRunNr, "sub-run number", 0u);
46 addParam("RunNr", m_runNr, "run number", 0u);
47 addParam("ExpNr", m_expNr, "exp number", 0u);
48 m_buffer = new int[MAXEVTSIZE];
49
50 B2DEBUG(29, "PXDReadRawBonnDAQModule: Constructor done.");
51}
52
53
58
60{
61 // Open file
63 if (fh) {
64 B2INFO("Read BonnDAQ Data from " << m_filename);
65 } else {
66 B2ERROR("Could not open BonnDAQ Data: " << m_filename);
67 }
68
69 // Register EvtMetaData
71 // Register RawPXD
73
74 B2DEBUG(29, "PXDReadRawBonnDAQModule: initialized.");
75}
76
78{
79
80 if (!fh) {
81 B2ERROR("BonnDAQ Data file is not open ");
82 }
83
84 unsigned int triggernr = 0xFFFFFFFF;
85
86 struct EvtHeader {
87 ulittle16_t size;
88 ulittle16_t header;
89 unsigned int get_size(void) { return (unsigned int) size + (((unsigned int)(header & 0x000F)) << 16);};
90 unsigned int get_size_group(void) { return (unsigned int) size + (((unsigned int)((header & 0x003F) ^ 0x0020)) << 16);};
91 unsigned int get_header12(void) { return (header & 0xFFF0);};
92 unsigned int get_header10(void) { return (header & 0xFFC0);};
93 unsigned int get_header8(void) { return (header & 0xFF00);};
94 };
95
96 char* data = (char*)m_buffer;
97 struct EvtHeader* evt = (struct EvtHeader*)data;
98
99 while (1) {
100 ulittle32_t* data32 = (ulittle32_t*)data;
101 ulittle16_t* data16 = (ulittle16_t*)data;
102 // Read 8 bytes header (group)
103 int br = fh->read_data(data, 4);
104 if (br <= 0) return br;
105 unsigned int chunk_size = 0;
106 if (evt->get_header8() == 0) {
107 B2DEBUG(29, "Group Header $" << std::hex << evt->get_header10() << " Chunk size " << std::dec << evt->get_size());
108 chunk_size = evt->get_size_group();
109 } else {
110 B2DEBUG(29, "Header $" << std::hex << evt->get_header12() << " Chunk size " << std::dec << evt->get_size());
111 chunk_size = evt->get_size();
112 }
113 if (chunk_size <= 1) return 0;
114 br = fh->read_data(data + 4, chunk_size * 4 - 4);
115 if (br <= 0) return br;
116 if (evt->get_header12() == 0xe230) {
117 B2DEBUG(29, "File info " << std::hex << evt->get_header12() << " Events " << std::dec << data32[1]);
118 continue;
119 } else if (evt->get_header12() == 0xe100) {
120 B2DEBUG(29, "Info Event " << std::hex << evt->get_header12() << " RunNr $" << std::hex << data32[1]);
121 if (m_runNr == 0) m_runNr = data32[1]; // we assume it will not change within one file
122 continue;
123 } else if (evt->get_header10() == 0x0000) { // war 0x0020
124 B2DEBUG(29, "Run Event Group " << std::hex << evt->get_header10() << " Magic $" << std::hex << data32[1]);
125 continue;
126 } else if (evt->get_header12() == 0xbb00) {
127 B2DEBUG(29, "Run Event " << std::hex << evt->get_header12() << " Magic $" << std::hex << data32[1]);
128 continue;
129 } else if (evt->get_header10() == 0x0080) { // war 0x00A0
130 int togo = chunk_size;
131 B2DEBUG(29, "Data Event Group " << std::hex << evt->get_header10() << " TriggerNr $" << std::hex << data32[1]);
132 triggernr = data32[1];
133 togo -= 2;
134 data32 += 2;
135 data16 += 4;
136 while (togo > 2) {
137 B2DEBUG(29, "TOGO: " << togo);
138 B2DEBUG(29, " ............... " << std::hex << data32[0] << " TriggerNr $" << std::hex << data32[1]);
139 if (triggernr != data32[1]) B2ERROR("Trigger Nr does not match!");
140 B2DEBUG(29, " ............... " << std::hex << data32[2]);
141 togo -= 2;
142 data32 += 2;
143 data16 += 4;
144 if ((data32[0] & 0xFFFF0000) == 0xCAFE0000) {
145 int frames = (data32[0] & 0x3FF);
146 B2DEBUG(29, "Frames: " << frames);
147 int size = 0;
148 bool nocrc = (data32[0] & 0x8000) != 0;
149
150 if ((data32[0] & 0x4000) == 0) B2FATAL("large data fields not supported");
151
152 togo--;
153 data32++;
154 data16 += 2;
156 std::vector <unsigned int> m_onsen_header;
157
159 std::vector <std::vector <unsigned char>> m_onsen_payload;
160 int offset = ((frames + 1) & ~1);
161
162 ulittle16_t* table16 = data16;
163 if (!nocrc) {
164 togo--; // jump over TOC CRC
165 data32++;
166 data16 += 2;
167 }
168
169 for (int i = 0; i < frames; i++) {
170 //B2INFO(".... " << i << ": " << table16[i]); -> do we need this?
171 size += table16[i];
172
174 std::vector <unsigned char> m_current_frame;
175
176 for (int j = 0; j < (int)table16[i] * 2; j++) {
177 unsigned short w = data16[offset++];
178 m_current_frame.push_back((unsigned char)(w >> 8));
179 m_current_frame.push_back((unsigned char)(w));
180 }
181
182 if (nocrc) { // recalculate
183 dhe_crc_32_type current_crc;
184 current_crc.process_bytes(m_current_frame.data(), m_current_frame.size());
185 unsigned int w = current_crc.checksum();
186 m_current_frame.push_back((unsigned char)(w >> 24));
187 m_current_frame.push_back((unsigned char)(w >> 16));
188 m_current_frame.push_back((unsigned char)(w >> 8));
189 m_current_frame.push_back((unsigned char)(w));
190 }
191
192 m_onsen_header.push_back(m_current_frame.size());
193 m_onsen_payload.push_back(m_current_frame);
194 }
195 togo -= ((frames + 1) & ~1) / 2 + size;
196 data32 += ((frames + 1) & ~1) / 2 + size;
197 data16 += ((frames + 1) & ~1) + size * 2;
198
199 if (nocrc) {
200 togo--;
201 data32++;
202 data16 += 2;
203 }
204
205 m_rawPXD.appendNew(m_onsen_header, m_onsen_payload);
206 }
207 }// while ...
208
209 // Update EventMetaData
210 B2INFO("Set Meta: Exp " << m_expNr << " Run " << m_runNr << " TrgNr " << triggernr);
211 m_eventMetaDataPtr.create();
212 m_eventMetaDataPtr->setExperiment(m_expNr);
214 m_eventMetaDataPtr->setEvent(triggernr);
215 // we cannot recover time tag here. this would need further decoding from DHH header
216 // m_eventMetaDataPtr->setTime((unsigned long long int)((time_tag_hi<<1) +(time_tag_mid &0x8000?1:0))*1000000000+(int)std::round(tt / 0.127216));
217
218 return 1;
219 } else {
220 B2ERROR("Undefine Header $" << std::hex << evt->get_header12());
221 continue;
222 }
223 continue;
224
225 }
226 return 0;
227}
228
230{
231 if (fh == 0) {
232 B2ERROR("Unexpected close of dump file.");
233 terminate();
234 return;
235 }
236
237 // Get a record from file
238 int stat;
239 do {
240 stat = readOneEvent();
241 if (stat <= 0) {
243 terminate();
244 return;
245 };
246 } while (stat == 0);
247
248 return;
249}
250
252{
253 if (fh) {
254 delete (fh);
255 fh = 0;
256 }
257}
@ c_ErrorIfAlreadyRegistered
If the object/array was already registered, produce an error (aborting initialisation).
Definition DataStore.h:72
void setDescription(const std::string &description)
Sets the description of the module.
Definition Module.cc:214
Module()
Constructor.
Definition Module.cc:30
A class to manage I/O for a chain of blocked files.
void initialize() override final
Initialize.
void terminate() override final
Terminate.
~PXDReadRawBonnDAQModule() override final
Destructor.
StoreObjPtr< EventMetaData > m_eventMetaDataPtr
Event Meta Data.
PXDLocalDAQFile * fh
File handle.
StoreArray< RawPXD > m_rawPXD
DHH Data.
void addParam(const std::string &name, T &paramVariable, const std::string &description, const T &defaultValue)
Adds a new parameter to the module.
Definition Module.h:559
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition Module.h:649
Namespace to encapsulate code needed for simulation and reconstrucion of the PXD.
boost::endian::little_uint16_t ulittle16_t
define alias ulittle16_t
boost::endian::little_uint32_t ulittle32_t
define alias ulittle32_t
Abstract base class for different kinds of events.
STL namespace.
Header structure of streamed object list.
Definition EvtMessage.h:28