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
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"
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;
65 std::unique_ptr<HighFive::File> file_;
67 HighFive::DataSetCreateProps fragmentCProps_;
68 HighFive::DataSetAccessProps fragmentAProps_;
70 void writeFragment_(HighFive::Group& group, artdaq::Fragment
const& frag);
71 artdaq::FragmentPtr readFragment_(HighFive::DataSet
const& dataset);
77 :
FragmentDataset(ps, ps.get<std::string>(
"mode",
"write")), file_(nullptr), eventIndex_(0)
79 TLOG(TLVL_DEBUG) <<
"HighFiveGeoCmpltPDSPSample CONSTRUCTOR BEGIN";
80 if (
mode_ == FragmentDatasetMode::Read)
82 file_.reset(
new HighFive::File(ps.get<std::string>(
"fileName"), HighFive::File::ReadOnly));
86 file_.reset(
new HighFive::File(ps.get<std::string>(
"fileName"), HighFive::File::OpenOrCreate | HighFive::File::Truncate));
88 TLOG(TLVL_DEBUG) <<
"HighFiveGeoCmpltPDSPSample CONSTRUCTOR END";
93 TLOG(TLVL_DEBUG) <<
"~HighFiveGeoCmpltPDSPSample Begin/End ";
99 TLOG(TLVL_TRACE) <<
"insertOne BEGIN";
100 if (!file_->exist(std::to_string(frag.sequenceID())))
102 TLOG(TLVL_INSERTONE) <<
"insertOne: Creating group for sequence ID " << frag.sequenceID();
103 file_->createGroup(std::to_string(frag.sequenceID()));
105 auto eventGroup = file_->getGroup(std::to_string(frag.sequenceID()));
109 if (frag.type() == Fragment::ContainerFragmentType)
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))
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))
120 TLOG(TLVL_INSERTONE) <<
"insertOne: Creating group for type " << typeName;
121 eventGroup.createGroup(typeName);
124 TLOG(TLVL_INSERTONE) <<
"insertOne: Creating group and setting attributes";
125 auto typeGroup = eventGroup.getGroup(typeName);
126 std::string containerName =
"Container0";
129 while (typeGroup.exist(containerName))
132 containerName =
"Container" + std::to_string(counter);
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());
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());
148 TLOG(TLVL_INSERTONE) <<
"insertOne: Writing Container contained Fragments";
149 for (
size_t ii = 0; ii < cf.block_count(); ++ii)
155 writeFragment_(containerGroup, *fragPtr);
158 else if (cf.block_count() == 1 || cf.fragment_type() == 10)
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))
165 TLOG(TLVL_INSERTONE) <<
"insertOne: Creating group for type " << typeName;
166 eventGroup.createGroup(typeName);
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)
177 writeFragment_(typeGroup, *fragPtr);
183 TLOG(TLVL_INSERTONE) <<
"insertOne: Writing Empty Container Fragment as standard Fragment";
184 auto typeName = nameHelper_->GetInstanceNameForFragment(frag).second;
185 if (!eventGroup.exist(typeName))
187 TLOG(TLVL_INSERTONE) <<
"insertOne: Creating group for type " << typeName;
188 eventGroup.createGroup(typeName);
190 auto typeGroup = eventGroup.getGroup(typeName);
192 writeFragment_(typeGroup, frag);
196 else if (frag.type() == 5)
198 TLOG(TLVL_INSERTONE) <<
"insertOne: Writing Timing Fragment";
199 writeFragment_(eventGroup, frag);
203 TLOG(TLVL_INSERTONE) <<
"insertOne: Writing non-Container Fragment";
204 auto typeName = nameHelper_->GetInstanceNameForFragment(frag).second;
205 if (!eventGroup.exist(typeName))
207 TLOG(TLVL_INSERTONE) <<
"insertOne: Creating group for type " << typeName;
208 eventGroup.createGroup(typeName);
210 auto typeGroup = eventGroup.getGroup(typeName);
212 writeFragment_(typeGroup, frag);
214 TLOG(TLVL_TRACE) <<
"insertOne END";
219 TLOG(TLVL_TRACE) <<
"insertMany BEGIN";
220 for (
auto& f : fs) insertOne(f);
221 TLOG(TLVL_TRACE) <<
"insertMany END";
226 TLOG(TLVL_TRACE) <<
"insertHeader BEGIN";
227 if (!file_->exist(std::to_string(hdr.sequence_id)))
229 TLOG(TLVL_INSERTHEADER) <<
"insertHeader: Creating group for event " << hdr.sequence_id;
230 file_->createGroup(std::to_string(hdr.sequence_id));
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";
242 TLOG(TLVL_DEBUG) <<
"readNextEvent BEGIN";
243 std::unordered_map<artdaq::Fragment::type_t, std::unique_ptr<artdaq::Fragments>> output;
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)
252 if (groupNames.size() <= eventIndex_)
254 TLOG(TLVL_INFO) <<
"readNextEvent: No more events in file!";
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();
262 for (
auto& fragment_type : fragment_type_names)
264 if (event_group.getObjectType(fragment_type) != HighFive::ObjectType::Group)
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();
272 for (
auto& fragment_name : fragment_names)
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)
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))
290 output[type].reset(
new Fragments());
292 output[type]->emplace_back(seqID, fragID);
293 output[type]->back().setTimestamp(timestamp);
294 output[type]->back().setSystemType(type);
296 TLOG(TLVL_READNEXTEVENT) <<
"readNextEvent: Creating ContainerFragmentLoader for reading Container Fragments";
297 ContainerFragmentLoader cfl(output[type]->back());
299 Fragment::type_t container_fragment_type;
301 container_group.getAttribute(
"container_fragment_type").read(container_fragment_type);
302 container_group.getAttribute(
"container_missing_data").read(missing_data);
304 cfl.set_fragment_type(container_fragment_type);
305 cfl.set_missing_data(missing_data);
307 TLOG(TLVL_READNEXTEVENT) <<
"readNextEvent: Reading ContainerFragment Fragments";
308 auto fragments = container_group.listObjectNames();
309 for (
auto& fragname : fragments)
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";
316 TLOG(TLVL_READNEXTEVENT_V) <<
"readNextEvent: Calling addFragment BEGIN";
317 cfl.addFragment(frag);
318 TLOG(TLVL_READNEXTEVENT_V) <<
"readNextEvent: addFragment END";
321 else if (node_type == HighFive::ObjectType::Dataset)
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";
327 TLOG(TLVL_READNEXTEVENT) <<
"readNextEvent: Adding Fragment to output";
328 if (!output.count(frag->type()))
330 output[frag->type()].reset(
new artdaq::Fragments());
332 output[frag->type()]->push_back(*frag.release());
340 <<
"readNextEvent END output.size() = " << output.size();
346 TLOG(TLVL_TRACE) <<
"GetEventHeader BEGIN seqID=" << seqID;
347 if (!file_->exist(std::to_string(seqID)))
349 TLOG(TLVL_ERROR) <<
"Sequence ID " << seqID <<
" not found in input file!";
352 auto seqIDGroup = file_->getGroup(std::to_string(seqID));
354 uint32_t runID, subrunID, eventID;
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);
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);
365 TLOG(TLVL_TRACE) <<
"GetEventHeader END";
366 return std::make_unique<artdaq::detail::RawEventHeader>(hdr);
369 void artdaq::hdf5::HighFiveGeoCmpltPDSPSample::writeFragment_(HighFive::Group& group, artdaq::Fragment
const& frag)
371 TLOG(TLVL_TRACE) <<
"writeFragment_ BEGIN";
373 std::string datasetNameBase =
"TimeSlice";
374 std::string datasetName =
"TimeSlice0";
379 datasetNameBase =
"APA3." + std::to_string((
int)(frag.fragmentID() % 10));
380 datasetName = datasetNameBase;
383 datasetNameBase =
"APA" + std::to_string((
int)(frag.fragmentID() / 10)) +
"." + std::to_string(-1 + (
int)(frag.fragmentID() % 10));
384 datasetName = datasetNameBase;
387 datasetNameBase =
"Timing";
388 datasetName = datasetNameBase;
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;
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;
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;
406 TLOG(TLVL_DEBUG) <<
"Metadata address and data: " << std::hex << mdPtr <<
", " << *mdPtr << std::dec;
408 if (frag.size() == 349397)
410 uint64_t* dataPtr =
const_cast<uint64_t*
>(beginPtr);
412 for (
int idx = 0; idx < 20; ++idx)
414 TLOG(TLVL_DEBUG) << std::hex << *dataPtr << std::dec;
416 double duneTime = (*dataPtr) * 0.000000020;
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;
426 while (dataPtr <= endPtr)
428 TLOG(TLVL_DEBUG) << std::hex << *dataPtr << std::dec;
430 double duneTime = (*dataPtr) * 0.000000020;
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;
442 TLOG(TLVL_DEBUG) <<
"Skipping Dataset: " << datasetName <<
", fragment size=" << frag.size();
449 while (group.exist(datasetName))
452 datasetName = datasetNameBase + std::to_string(counter);
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_);
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);
468 fragDset.createAttribute(
"sequence_id", fragHdr.sequence_id);
469 fragDset.createAttribute(
"fragment_id", fragHdr.fragment_id);
471 fragDset.createAttribute(
"timestamp", fragHdr.timestamp);
473 fragDset.createAttribute(
"valid", fragHdr.valid);
474 fragDset.createAttribute(
"complete", fragHdr.complete);
478 double duneTime = fragHdr.timestamp * 0.000000020;
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);
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";
492 artdaq::FragmentPtr artdaq::hdf5::HighFiveGeoCmpltPDSPSample::readFragment_(HighFive::DataSet
const& dataset)
494 TLOG(TLVL_TRACE) <<
"readFragment_ BEGIN";
496 dataset.getAttribute(
"fragment_data_size").read(fragSize);
497 TLOG(TLVL_READFRAGMENT) <<
"readFragment_: Fragment size " << fragSize <<
", dataset size " << dataset.getDimensions()[0];
499 artdaq::FragmentPtr frag(
new Fragment(fragSize));
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;
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);
512 dataset.getAttribute(
"sequence_id").read(seqID);
513 dataset.getAttribute(
"fragment_id").read(fragID);
515 dataset.getAttribute(
"timestamp").read(timestamp);
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);
522 auto fragHdr = frag->fragmentHeader();
524 fragHdr.metadata_word_count = metadata_size;
526 fragHdr.sequence_id = seqID;
527 fragHdr.fragment_id = fragID;
529 fragHdr.timestamp = timestamp;
531 fragHdr.valid = valid;
532 fragHdr.complete = complete;
533 fragHdr.atime_ns = atime_ns;
534 fragHdr.atime_s = atime_s;
536 TLOG(TLVL_READFRAGMENT) <<
"readFragment_: Copying header into Fragment";
537 memcpy(frag->headerAddress(), &fragHdr,
sizeof(fragHdr));
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";
543 TLOG(TLVL_TRACE) <<
"readFragment_ END";
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.