artdaq_demo_hdf5  v1_03_01
highFiveGeoCmpltPDSPSample_dataset.cc
1 #include "tracemf.h"
2 #define TRACE_NAME "HighFiveGeoCmpltPDSPSample"
3 #define TLVL_INSERTONE 6
4 #define TLVL_INSERTHEADER 7
5 #define TLVL_WRITEFRAGMENT 8
6 #define TLVL_WRITEFRAGMENT_V 9
7 #define TLVL_READNEXTEVENT 10
8 #define TLVL_READNEXTEVENT_V 11
9 #define TLVL_READFRAGMENT 12
10 #define TLVL_READFRAGMENT_V 13
11 #define TLVL_GETEVENTHEADER 14
12 
13 #include <unordered_map>
14 #include "artdaq-core/Data/ContainerFragmentLoader.hh"
15 #include "artdaq-core/Utilities/TimeUtils.hh"
16 #include "artdaq-demo-hdf5/HDF5/FragmentDataset.hh"
17 #include "artdaq-demo-hdf5/HDF5/highFive/HighFive/include/highfive/H5File.hpp"
18 
19 namespace artdaq {
20 namespace hdf5 {
25 {
26 public:
31  HighFiveGeoCmpltPDSPSample(fhicl::ParameterSet const& ps);
36 
41  void insertOne(artdaq::Fragment const& frag) override;
46  void insertMany(artdaq::Fragments const& frags) override;
51  void insertHeader(artdaq::detail::RawEventHeader const& hdr) override;
56  std::unordered_map<artdaq::Fragment::type_t, std::unique_ptr<artdaq::Fragments>> readNextEvent() override;
62  std::unique_ptr<artdaq::detail::RawEventHeader> getEventHeader(artdaq::Fragment::sequence_id_t const& seqID) override;
63 
64 private:
65  std::unique_ptr<HighFive::File> file_;
66  size_t eventIndex_;
67  HighFive::DataSetCreateProps fragmentCProps_;
68  HighFive::DataSetAccessProps fragmentAProps_;
69 
70  void writeFragment_(HighFive::Group& group, artdaq::Fragment const& frag);
71  artdaq::FragmentPtr readFragment_(HighFive::DataSet const& dataset);
72 };
73 } // namespace hdf5
74 } // namespace artdaq
75 
77  : FragmentDataset(ps, ps.get<std::string>("mode", "write")), file_(nullptr), eventIndex_(0)
78 {
79  TLOG(TLVL_DEBUG) << "HighFiveGeoCmpltPDSPSample CONSTRUCTOR BEGIN";
80  if (mode_ == FragmentDatasetMode::Read)
81  {
82  file_.reset(new HighFive::File(ps.get<std::string>("fileName"), HighFive::File::ReadOnly));
83  }
84  else
85  {
86  file_.reset(new HighFive::File(ps.get<std::string>("fileName"), HighFive::File::OpenOrCreate | HighFive::File::Truncate));
87  }
88  TLOG(TLVL_DEBUG) << "HighFiveGeoCmpltPDSPSample CONSTRUCTOR END";
89 }
90 
92 {
93  TLOG(TLVL_DEBUG) << "~HighFiveGeoCmpltPDSPSample Begin/End ";
94  // file_->flush();
95 }
96 
97 void artdaq::hdf5::HighFiveGeoCmpltPDSPSample::insertOne(artdaq::Fragment const& frag)
98 {
99  TLOG(TLVL_TRACE) << "insertOne BEGIN";
100  if (!file_->exist(std::to_string(frag.sequenceID())))
101  {
102  TLOG(TLVL_INSERTONE) << "insertOne: Creating group for sequence ID " << frag.sequenceID();
103  file_->createGroup(std::to_string(frag.sequenceID()));
104  }
105  auto eventGroup = file_->getGroup(std::to_string(frag.sequenceID()));
106 
107  // fragment_type_map: [[1, "MISSED"], [2, "TPC"], [3, "PHOTON"], [4, "TRIGGER"], [5, "TIMING"], [6, "TOY1"], [7, "TOY2"], [8, "FELIX"], [9, "CRT"], [10, "CTB"], [11, "CPUHITS"], [12, "DEVBOARDHITS"], [13, "UNKNOWN"]]
108 
109  if (frag.type() == Fragment::ContainerFragmentType)
110  {
111  TLOG(TLVL_INSERTONE) << "insertOne: Processing ContainerFragment";
112  ContainerFragment cf(frag);
113  if (cf.fragment_type() != 10 && (cf.block_count() > 1 || cf.fragment_type() == 9))
114  {
115  TLOG(TLVL_INSERTONE) << "insertOne: Getting Fragment type name";
116  auto fragPtr = cf.at(0);
117  auto typeName = nameHelper_->GetInstanceNameForFragment(*fragPtr).second;
118  if (!eventGroup.exist(typeName))
119  {
120  TLOG(TLVL_INSERTONE) << "insertOne: Creating group for type " << typeName;
121  eventGroup.createGroup(typeName);
122  }
123 
124  TLOG(TLVL_INSERTONE) << "insertOne: Creating group and setting attributes";
125  auto typeGroup = eventGroup.getGroup(typeName);
126  std::string containerName = "Container0";
127 
128  int counter = 1;
129  while (typeGroup.exist(containerName))
130  {
131  //TLOG(TLVL_WRITEFRAGMENT) << "writeFragment_: Duplicate Fragment ID " << frag.fragmentID() << " detected. If this is a ContainerFragment, this is expected, otherwise check configuration!";
132  containerName = "Container" + std::to_string(counter);
133  counter++;
134  }
135 
136  auto containerGroup = typeGroup.createGroup(containerName);
137  containerGroup.createAttribute("version", frag.version());
138  containerGroup.createAttribute("type", frag.type());
139  containerGroup.createAttribute("sequence_id", frag.sequenceID());
140  containerGroup.createAttribute("fragment_id", frag.fragmentID());
141  containerGroup.createAttribute("timestamp", frag.timestamp());
142 
143  containerGroup.createAttribute("container_block_count", cf.block_count());
144  containerGroup.createAttribute("container_fragment_type", cf.fragment_type());
145  containerGroup.createAttribute("container_version", cf.metadata()->version);
146  containerGroup.createAttribute("container_missing_data", cf.missing_data());
147 
148  TLOG(TLVL_INSERTONE) << "insertOne: Writing Container contained Fragments";
149  for (size_t ii = 0; ii < cf.block_count(); ++ii)
150  {
151  if (ii != 0)
152  {
153  fragPtr = cf.at(ii);
154  }
155  writeFragment_(containerGroup, *fragPtr);
156  }
157  }
158  else if (cf.block_count() == 1 || cf.fragment_type() == 10)
159  {
160  TLOG(TLVL_INSERTONE) << "insertOne: Getting Fragment type name";
161  auto fragPtr = cf.at(0);
162  auto typeName = nameHelper_->GetInstanceNameForFragment(*fragPtr).second;
163  if (!eventGroup.exist(typeName))
164  {
165  TLOG(TLVL_INSERTONE) << "insertOne: Creating group for type " << typeName;
166  eventGroup.createGroup(typeName);
167  }
168 
169  TLOG(TLVL_INSERTONE) << "insertOne: Creating type group";
170  auto typeGroup = eventGroup.getGroup(typeName);
171  for (size_t ii = 0; ii < cf.block_count(); ++ii)
172  {
173  if (ii != 0)
174  {
175  fragPtr = cf.at(ii);
176  }
177  writeFragment_(typeGroup, *fragPtr);
178  }
179  }
180 #if 0
181  else
182  {
183  TLOG(TLVL_INSERTONE) << "insertOne: Writing Empty Container Fragment as standard Fragment";
184  auto typeName = nameHelper_->GetInstanceNameForFragment(frag).second;
185  if (!eventGroup.exist(typeName))
186  {
187  TLOG(TLVL_INSERTONE) << "insertOne: Creating group for type " << typeName;
188  eventGroup.createGroup(typeName);
189  }
190  auto typeGroup = eventGroup.getGroup(typeName);
191 
192  writeFragment_(typeGroup, frag);
193  }
194 #endif
195  }
196  else if (frag.type() == 5) // Timing
197  {
198  TLOG(TLVL_INSERTONE) << "insertOne: Writing Timing Fragment";
199  writeFragment_(eventGroup, frag);
200  }
201  else
202  {
203  TLOG(TLVL_INSERTONE) << "insertOne: Writing non-Container Fragment";
204  auto typeName = nameHelper_->GetInstanceNameForFragment(frag).second;
205  if (!eventGroup.exist(typeName))
206  {
207  TLOG(TLVL_INSERTONE) << "insertOne: Creating group for type " << typeName;
208  eventGroup.createGroup(typeName);
209  }
210  auto typeGroup = eventGroup.getGroup(typeName);
211 
212  writeFragment_(typeGroup, frag);
213  }
214  TLOG(TLVL_TRACE) << "insertOne END";
215 }
216 
218 {
219  TLOG(TLVL_TRACE) << "insertMany BEGIN";
220  for (auto& f : fs) insertOne(f);
221  TLOG(TLVL_TRACE) << "insertMany END";
222 }
223 
224 void artdaq::hdf5::HighFiveGeoCmpltPDSPSample::insertHeader(artdaq::detail::RawEventHeader const& hdr)
225 {
226  TLOG(TLVL_TRACE) << "insertHeader BEGIN";
227  if (!file_->exist(std::to_string(hdr.sequence_id)))
228  {
229  TLOG(TLVL_INSERTHEADER) << "insertHeader: Creating group for event " << hdr.sequence_id;
230  file_->createGroup(std::to_string(hdr.sequence_id));
231  }
232  auto eventGroup = file_->getGroup(std::to_string(hdr.sequence_id));
233  eventGroup.createAttribute("run_id", hdr.run_id);
234  eventGroup.createAttribute("subrun_id", hdr.subrun_id);
235  eventGroup.createAttribute("event_id", hdr.event_id);
236  eventGroup.createAttribute("is_complete", hdr.is_complete);
237  TLOG(TLVL_TRACE) << "insertHeader END";
238 }
239 
240 std::unordered_map<artdaq::Fragment::type_t, std::unique_ptr<artdaq::Fragments>> artdaq::hdf5::HighFiveGeoCmpltPDSPSample::readNextEvent()
241 {
242  TLOG(TLVL_DEBUG) << "readNextEvent BEGIN";
243  std::unordered_map<artdaq::Fragment::type_t, std::unique_ptr<artdaq::Fragments>> output;
244 
245  TLOG(TLVL_READNEXTEVENT) << "readNextEvent: Finding next event group in file";
246  auto groupNames = file_->listObjectNames();
247  while (eventIndex_ < groupNames.size() && file_->getObjectType(groupNames[eventIndex_]) != HighFive::ObjectType::Group)
248  {
249  eventIndex_++;
250  }
251 
252  if (groupNames.size() <= eventIndex_)
253  {
254  TLOG(TLVL_INFO) << "readNextEvent: No more events in file!";
255  }
256  else
257  {
258  TLOG(TLVL_READNEXTEVENT) << "readNextEvent: Getting event group " << groupNames[eventIndex_];
259  auto event_group = file_->getGroup(groupNames[eventIndex_]);
260  auto fragment_type_names = event_group.listObjectNames();
261 
262  for (auto& fragment_type : fragment_type_names)
263  {
264  if (event_group.getObjectType(fragment_type) != HighFive::ObjectType::Group)
265  {
266  continue;
267  }
268  TLOG(TLVL_READNEXTEVENT) << "readNextEvent: Reading Fragment type " << fragment_type;
269  auto type_group = event_group.getGroup(fragment_type);
270  auto fragment_names = type_group.listObjectNames();
271 
272  for (auto& fragment_name : fragment_names)
273  {
274  TLOG(TLVL_READNEXTEVENT) << "readNextEvent: Reading Fragment " << fragment_name;
275  auto node_type = type_group.getObjectType(fragment_name);
276  if (node_type == HighFive::ObjectType::Group)
277  {
278  TLOG(TLVL_READNEXTEVENT) << "readNextEvent: Fragment " << fragment_name << " is a Container";
279  auto container_group = type_group.getGroup(fragment_name);
280  Fragment::type_t type;
281  container_group.getAttribute("type").read<Fragment::type_t>(type);
282  Fragment::sequence_id_t seqID;
283  container_group.getAttribute("sequence_id").read(seqID);
284  Fragment::timestamp_t timestamp;
285  container_group.getAttribute("timestamp").read(timestamp);
286  Fragment::fragment_id_t fragID;
287  container_group.getAttribute("fragment_id").read(fragID);
288  if (!output.count(type))
289  {
290  output[type].reset(new Fragments());
291  }
292  output[type]->emplace_back(seqID, fragID);
293  output[type]->back().setTimestamp(timestamp);
294  output[type]->back().setSystemType(type);
295 
296  TLOG(TLVL_READNEXTEVENT) << "readNextEvent: Creating ContainerFragmentLoader for reading Container Fragments";
297  ContainerFragmentLoader cfl(output[type]->back());
298 
299  Fragment::type_t container_fragment_type;
300  int missing_data;
301  container_group.getAttribute("container_fragment_type").read(container_fragment_type);
302  container_group.getAttribute("container_missing_data").read(missing_data);
303 
304  cfl.set_fragment_type(container_fragment_type);
305  cfl.set_missing_data(missing_data);
306 
307  TLOG(TLVL_READNEXTEVENT) << "readNextEvent: Reading ContainerFragment Fragments";
308  auto fragments = container_group.listObjectNames();
309  for (auto& fragname : fragments)
310  {
311  if (container_group.getObjectType(fragname) != HighFive::ObjectType::Dataset) continue;
312  TLOG(TLVL_READNEXTEVENT_V) << "readNextEvent: Calling readFragment_ BEGIN";
313  auto frag = readFragment_(container_group.getDataSet(fragname, fragmentAProps_));
314  TLOG(TLVL_READNEXTEVENT_V) << "readNextEvent: Calling readFragment_ END";
315 
316  TLOG(TLVL_READNEXTEVENT_V) << "readNextEvent: Calling addFragment BEGIN";
317  cfl.addFragment(frag);
318  TLOG(TLVL_READNEXTEVENT_V) << "readNextEvent: addFragment END";
319  }
320  }
321  else if (node_type == HighFive::ObjectType::Dataset)
322  {
323  TLOG(TLVL_READNEXTEVENT_V) << "readNextEvent: Calling readFragment_ BEGIN";
324  auto frag = readFragment_(type_group.getDataSet(fragment_name, fragmentAProps_));
325  TLOG(TLVL_READNEXTEVENT_V) << "readNextEvent: Calling readFragment_ END";
326 
327  TLOG(TLVL_READNEXTEVENT) << "readNextEvent: Adding Fragment to output";
328  if (!output.count(frag->type()))
329  {
330  output[frag->type()].reset(new artdaq::Fragments());
331  }
332  output[frag->type()]->push_back(*frag.release());
333  }
334  }
335  }
336  }
337  ++eventIndex_;
338 
339  TLOG(TLVL_DEBUG)
340  << "readNextEvent END output.size() = " << output.size();
341  return output;
342 }
343 
344 std::unique_ptr<artdaq::detail::RawEventHeader> artdaq::hdf5::HighFiveGeoCmpltPDSPSample::getEventHeader(artdaq::Fragment::sequence_id_t const& seqID)
345 {
346  TLOG(TLVL_TRACE) << "GetEventHeader BEGIN seqID=" << seqID;
347  if (!file_->exist(std::to_string(seqID)))
348  {
349  TLOG(TLVL_ERROR) << "Sequence ID " << seqID << " not found in input file!";
350  return nullptr;
351  }
352  auto seqIDGroup = file_->getGroup(std::to_string(seqID));
353 
354  uint32_t runID, subrunID, eventID;
355  uint64_t timestamp;
356  seqIDGroup.getAttribute("run_id").read(runID);
357  seqIDGroup.getAttribute("subrun_id").read(subrunID);
358  seqIDGroup.getAttribute("event_id").read(eventID);
359  seqIDGroup.getAttribute("timestamp").read(timestamp);
360 
361  TLOG(TLVL_GETEVENTHEADER) << "Creating EventHeader with runID " << runID << ", subrunID " << subrunID << ", eventID " << eventID << ", timestamp " << timestamp << " (seqID " << seqID << ")";
362  artdaq::detail::RawEventHeader hdr(runID, subrunID, eventID, seqID, timestamp);
363  seqIDGroup.getAttribute("is_complete").read(hdr.is_complete);
364 
365  TLOG(TLVL_TRACE) << "GetEventHeader END";
366  return std::make_unique<artdaq::detail::RawEventHeader>(hdr);
367 }
368 
369 void artdaq::hdf5::HighFiveGeoCmpltPDSPSample::writeFragment_(HighFive::Group& group, artdaq::Fragment const& frag)
370 {
371  TLOG(TLVL_TRACE) << "writeFragment_ BEGIN";
372 
373  std::string datasetNameBase = "TimeSlice";
374  std::string datasetName = "TimeSlice0";
375 
376  switch (frag.type())
377  {
378  case 2: // TPC
379  datasetNameBase = "APA3." + std::to_string((int)(frag.fragmentID() % 10));
380  datasetName = datasetNameBase;
381  break;
382  case 3: // Photon
383  datasetNameBase = "APA" + std::to_string((int)(frag.fragmentID() / 10)) + "." + std::to_string(-1 + (int)(frag.fragmentID() % 10));
384  datasetName = datasetNameBase;
385  break;
386  case 5: // Timing
387  datasetNameBase = "Timing";
388  datasetName = datasetNameBase;
389  break;
390  case 8: // FELIX
391  int apaNumber = ((int)(frag.fragmentID() / 10)) % 10;
392  if (apaNumber == 3) { apaNumber = 2; }
393  datasetNameBase = "APA" + std::to_string(apaNumber) + "." + std::to_string((int)(frag.fragmentID() % 10));
394  datasetName = datasetNameBase;
395  //TLOG(TLVL_DEBUG) << "Skipping Dataset: " << datasetName << ", fragment size=" << frag.size();
396 
397  const uint8_t* tmpBeginPtr = frag.dataBeginBytes();
398  const uint8_t* tmpEndPtr = frag.dataEndBytes();
399  const uint64_t* beginPtr = reinterpret_cast<const uint64_t*>(tmpBeginPtr);
400  const uint64_t* endPtr = reinterpret_cast<const uint64_t*>(tmpEndPtr);
401  TLOG(TLVL_DEBUG) << "Data addresses in hex: " << std::hex << tmpBeginPtr << ", " << tmpEndPtr << ", " << beginPtr << ", " << endPtr << std::dec;
402 
403  uint64_t* mdPtr = reinterpret_cast<uint64_t*>(const_cast<uint8_t*>(frag.headerBeginBytes()) + frag.headerSizeBytes());
404  TLOG(TLVL_DEBUG) << "Metadata address and data: " << std::hex << mdPtr << ", " << *mdPtr << std::dec;
405  ++mdPtr;
406  TLOG(TLVL_DEBUG) << "Metadata address and data: " << std::hex << mdPtr << ", " << *mdPtr << std::dec;
407 
408  if (frag.size() == 349397)
409  {
410  uint64_t* dataPtr = const_cast<uint64_t*>(beginPtr);
411  ++dataPtr;
412  for (int idx = 0; idx < 20; ++idx)
413  {
414  TLOG(TLVL_DEBUG) << std::hex << *dataPtr << std::dec;
415 
416  double duneTime = (*dataPtr) * 0.000000020;
417  timespec tsp;
418  tsp.tv_sec = (time_t)duneTime;
419  tsp.tv_nsec = (long)((duneTime - tsp.tv_sec) * 1000000000.0);
420  std::string timeString = artdaq::TimeUtils::convertUnixTimeToString(tsp);
421  TLOG(TLVL_DEBUG) << "Frame time is " << timeString;
422 
423  dataPtr += 58;
424  }
425  dataPtr += 347072;
426  while (dataPtr <= endPtr)
427  {
428  TLOG(TLVL_DEBUG) << std::hex << *dataPtr << std::dec;
429 
430  double duneTime = (*dataPtr) * 0.000000020;
431  timespec tsp;
432  tsp.tv_sec = (time_t)duneTime;
433  tsp.tv_nsec = (long)((duneTime - tsp.tv_sec) * 1000000000.0);
434  std::string timeString = artdaq::TimeUtils::convertUnixTimeToString(tsp);
435  TLOG(TLVL_DEBUG) << "Frame time is " << timeString;
436 
437  dataPtr += 58;
438  }
439  }
440  else
441  {
442  TLOG(TLVL_DEBUG) << "Skipping Dataset: " << datasetName << ", fragment size=" << frag.size();
443  }
444 
445  break;
446  }
447 
448  int counter = 1;
449  while (group.exist(datasetName))
450  {
451  //TLOG(TLVL_WRITEFRAGMENT) << "writeFragment_: Duplicate Fragment ID " << frag.fragmentID() << " detected. If this is a ContainerFragment, this is expected, otherwise check configuration!";
452  datasetName = datasetNameBase + std::to_string(counter);
453  counter++;
454  }
455 
456  TLOG(TLVL_WRITEFRAGMENT) << "writeFragment_: Creating DataSpace";
457  HighFive::DataSpace fragmentSpace = HighFive::DataSpace({frag.size() - frag.headerSizeWords(), 1});
458  auto fragDset = group.createDataSet<RawDataType>(datasetName, fragmentSpace, fragmentCProps_, fragmentAProps_);
459 
460  TLOG(TLVL_WRITEFRAGMENT) << "writeFragment_: Creating Attributes from Fragment Header";
461  auto fragHdr = frag.fragmentHeader();
462  fragDset.createAttribute("word_count", fragHdr.word_count);
463  fragDset.createAttribute("fragment_data_size", frag.size() - frag.headerSizeWords());
464  fragDset.createAttribute("version", fragHdr.version);
465  fragDset.createAttribute("type", fragHdr.type);
466  fragDset.createAttribute("metadata_word_count", fragHdr.metadata_word_count);
467 
468  fragDset.createAttribute("sequence_id", fragHdr.sequence_id);
469  fragDset.createAttribute("fragment_id", fragHdr.fragment_id);
470 
471  fragDset.createAttribute("timestamp", fragHdr.timestamp);
472 
473  fragDset.createAttribute("valid", fragHdr.valid);
474  fragDset.createAttribute("complete", fragHdr.complete);
475  //fragDset.createAttribute("atime_ns", fragHdr.atime_ns);
476  //fragDset.createAttribute("atime_s", fragHdr.atime_s);
477 
478  double duneTime = fragHdr.timestamp * 0.000000020;
479  timespec tsp;
480  tsp.tv_sec = (time_t)duneTime;
481  tsp.tv_nsec = (long)((duneTime - tsp.tv_sec) * 1000000000.0);
482  std::string timeString = artdaq::TimeUtils::convertUnixTimeToString(tsp);
483  TLOG(TLVL_DEBUG) << "Trigger time is " << timeString << " for Dataset: " << datasetName;
484  fragDset.createAttribute("time_string", timeString);
485 
486  TLOG(TLVL_WRITEFRAGMENT_V) << "writeFragment_: Writing Fragment payload START";
487  fragDset.write(frag.headerBegin() + frag.headerSizeWords());
488  TLOG(TLVL_WRITEFRAGMENT_V) << "writeFragment_: Writing Fragment payload DONE";
489  TLOG(TLVL_TRACE) << "writeFragment_ END";
490 }
491 
492 artdaq::FragmentPtr artdaq::hdf5::HighFiveGeoCmpltPDSPSample::readFragment_(HighFive::DataSet const& dataset)
493 {
494  TLOG(TLVL_TRACE) << "readFragment_ BEGIN";
495  size_t fragSize;
496  dataset.getAttribute("fragment_data_size").read(fragSize);
497  TLOG(TLVL_READFRAGMENT) << "readFragment_: Fragment size " << fragSize << ", dataset size " << dataset.getDimensions()[0];
498 
499  artdaq::FragmentPtr frag(new Fragment(fragSize));
500 
501  artdaq::Fragment::type_t type;
502  size_t metadata_size;
503  artdaq::Fragment::sequence_id_t seqID;
504  artdaq::Fragment::fragment_id_t fragID;
505  artdaq::Fragment::timestamp_t timestamp;
506  int valid, complete, atime_ns, atime_s;
507 
508  TLOG(TLVL_READFRAGMENT) << "readFragment_: Reading Fragment header fields from dataset attributes";
509  dataset.getAttribute("type").read(type);
510  dataset.getAttribute("metadata_word_count").read(metadata_size);
511 
512  dataset.getAttribute("sequence_id").read(seqID);
513  dataset.getAttribute("fragment_id").read(fragID);
514 
515  dataset.getAttribute("timestamp").read(timestamp);
516 
517  dataset.getAttribute("valid").read(valid);
518  dataset.getAttribute("complete").read(complete);
519  dataset.getAttribute("atime_ns").read(atime_ns);
520  dataset.getAttribute("atime_s").read(atime_s);
521 
522  auto fragHdr = frag->fragmentHeader();
523  fragHdr.type = type;
524  fragHdr.metadata_word_count = metadata_size;
525 
526  fragHdr.sequence_id = seqID;
527  fragHdr.fragment_id = fragID;
528 
529  fragHdr.timestamp = timestamp;
530 
531  fragHdr.valid = valid;
532  fragHdr.complete = complete;
533  fragHdr.atime_ns = atime_ns;
534  fragHdr.atime_s = atime_s;
535 
536  TLOG(TLVL_READFRAGMENT) << "readFragment_: Copying header into Fragment";
537  memcpy(frag->headerAddress(), &fragHdr, sizeof(fragHdr));
538 
539  TLOG(TLVL_READFRAGMENT_V) << "readFragment_: Reading payload data into Fragment BEGIN";
540  dataset.read(frag->headerAddress() + frag->headerSizeWords());
541  TLOG(TLVL_READFRAGMENT_V) << "readFragment_: Reading payload data into Fragment END";
542 
543  TLOG(TLVL_TRACE) << "readFragment_ END";
544  return frag;
545 }
546 
547 DEFINE_ARTDAQ_DATASET_PLUGIN(artdaq::hdf5::HighFiveGeoCmpltPDSPSample)
void insertMany(artdaq::Fragments const &frags) override
Write Fragments to HDF5.
void insertOne(artdaq::Fragment const &frag) override
Write a Fragment to HDF5.
void insertHeader(artdaq::detail::RawEventHeader const &hdr) override
Write a RawEventHeader to HDF5.
Sample ProtoDUNE HDF5 output which writes all data indexed by sequence ID.
FragmentDatasetMode mode_
Mode of this FragmentDataset, either FragmentDatasetMode::Write or FragmentDatasetMode::Read.
Base class that defines methods for reading and writing to HDF5 files via various implementation plug...
std::unordered_map< artdaq::Fragment::type_t, std::unique_ptr< artdaq::Fragments > > readNextEvent() override
Read event data from HDF5.
virtual ~HighFiveGeoCmpltPDSPSample()
HighFiveGeoCmpltPDSPSample Destructor.
std::unique_ptr< artdaq::detail::RawEventHeader > getEventHeader(artdaq::Fragment::sequence_id_t const &seqID) override
Read an Event Header from HDF55.
HighFiveGeoCmpltPDSPSample(fhicl::ParameterSet const &ps)
HighFiveGeoCmpltPDSPSample Constructor.