YODA::WriterH5 Class Reference

Persistency writer for YODA H5 format. More...

#include <WriterH5.h>

Inheritance diagram for YODA::WriterH5:

Static Public Member Functions
static Writer &	create ()
	Singleton creation function.

Protected Member Functions
void	writeAOS (YODA_H5::File &file, const std::vector< const AnalysisObject * > &aos)
Protected Member Functions inherited from YODA::Writer
virtual void	writeHead (std::ostream &)
	Write any opening boilerplate required by the format to stream.
virtual void	writeBody (std::ostream &stream, const AnalysisObject *ao)
	Write the body elements corresponding to AnalysisObject ao to stream.
virtual void	writeBody (std::ostream &stream, const AnalysisObject &ao)
	Write the body elements corresponding to AnalysisObject pointer ao to stream.
template<typename T >
std::enable_if_t< DerefableToAO< T >::value >	writeBody (std::ostream &stream, const T &ao)
	Write the body elements corresponding to AnalysisObject ao to stream.
virtual void	writeFoot (std::ostream &stream)
	Write any closing boilerplate required by the format to stream.

Additional Inherited Members
Public Member Functions inherited from YODA::Writer
virtual	~Writer ()
	Virtual destructor.
void	setPrecision (int precision)
	Set precision of numerical quantities in this writer's output.
void	setAOPrecision (const bool needsDP=false)
	Set precision of numerical quantities for current AO in this writer's output.
void	useCompression (const bool compress=true)
	Use libz compression?
void	write (const std::string &filename, const AnalysisObject &ao)
	Write out object ao to file filename.
void	write (std::ostream &stream, const AnalysisObject &ao)
	Write out object ao to output stream stream.
template<typename T >
std::enable_if_t< DerefableToAO< T >::value >	write (std::ostream &stream, const T &ao)
	Write out pointer-like object ao to output stream stream.
template<typename T >
std::enable_if_t< DerefableToAO< T >::value >	write (const std::string &filename, const T &ao)
	Write out pointer-like object ao to file filename.
void	write (YODA_H5::File &file, const std::vector< const AnalysisObject * > &aos)
void	write (std::ostream &stream, const std::vector< const AnalysisObject * > &aos, int precision=-1)
template<typename RANGE >
std::enable_if_t< CIterable< RANGE >::value >	write (std::ostream &stream, const RANGE &aos)
template<typename RANGE >
std::enable_if_t< CIterable< RANGE >::value >	write (const std::string &filename, const RANGE &aos)
	Write out a collection of objects objs to file filename.
template<typename AOITER >
void	write (std::ostream &stream, const AOITER &begin, const AOITER &end, int precision=-1)
template<typename AOITER >
void	write (const std::string &filename, const AOITER &begin, const AOITER &end)

Detailed Description

Persistency writer for YODA H5 format.

Definition at line 15 of file WriterH5.h.

Member Function Documentation

create()

Writer & YODA::WriterH5::create ( )

static

Singleton creation function.

Definition at line 17 of file WriterH5.cc.

                           {
    static WriterH5 _instance;
    _instance.setPrecision(6); //< not used
    return _instance;
  }

References YODA::Writer::setPrecision().

Referenced by YODA::mkWriter().

writeAOS()

void YODA::WriterH5::writeAOS ( YODA_H5::File &  file, const std::vector< const AnalysisObject * > &  aos  )

protectedvirtual

Implements YODA::Writer.

Definition at line 30 of file WriterH5.cc.

                                                                                      {
 
    // Work out the length of the concatenated serialized streams
    size_t annolen = 0, datalen = 0;
    vector<size_t> annosizes, datasizes, labelsizes;
    annosizes.reserve(aos.size());
    labelsizes.reserve(aos.size());
    datasizes.reserve(aos.size()+1); //< +1 for # of AOs requiring error labels
    vector<string> labels; // list of error labels
    for (const AnalysisObject* ao : aos) {
      annosizes.emplace_back(ao->lengthMeta() - 1); //< skip "Title" key
      datasizes.emplace_back(ao->lengthContent());
      annolen += annosizes.back();
      datalen += datasizes.back();
      // if the AO is an Estimate, extract the error labels
      ao->_extractLabels(labels, labelsizes);
    }
    datasizes.emplace_back(labelsizes.size());
    //size_t annochunk = annolen/aos.size();
    //size_t datachunk = datalen/aos.size();
    size_t annochunk = std::min(annolen, (size_t)1200);
    size_t datachunk = std::min(datalen, (size_t)1500);
 
    // create empty H5 DataSets
    H5DataSetWriter<string> annoset(h5, "annotations", annolen, annochunk, _compress);
    H5DataSetWriter<double> dataset(h5, "content", datalen, datachunk, _compress);
 
    // Now that we know the sizes of all AOs,
    // fill an uber-vector of serialized sub-vectors
    // as well as a map of edge handlers for binned AOs
    map<string, EdgeHandlerBasePtr> layout;
    layout["sizeinfo"] = std::make_shared<EdgeHandler<size_t>>();
    static_pointer_cast<EdgeHandler<size_t>>(layout["sizeinfo"])->extend(std::move(annosizes));
    static_pointer_cast<EdgeHandler<size_t>>(layout["sizeinfo"])->extend(std::move(datasizes));
    static_pointer_cast<EdgeHandler<size_t>>(layout["sizeinfo"])->extend(std::move(labelsizes));
    vector<string> aoinfo; aoinfo.reserve(H5FileManager::AO_META*aos.size());
    for (const AnalysisObject* ao : aos) {
 
      // save metadata about this AO
      aoinfo.emplace_back(ao->path());
      aoinfo.emplace_back(Utils::toUpper(ao->type()));
 
      // retrieve annotations for this AO
      vector<string> annos = ao->serializeMeta(); //< skips Path and Title
      annos.emplace_back(ao->title()); // title value should be at the end
 
      // retrieve content for this AO
      vector<double> content = ao->serializeContent();
 
      // write to file
      annoset.writeSlice(std::move(annos));
      dataset.writeSlice(std::move(content));
 
      // if the AO is a Fillable, extract its binning
      ao->_extractEdges(layout, labels);
    }
 
    // write AO metadata
    auto meta = H5DataSet(h5, "aoinfo", std::move(aoinfo), _compress);
 
    // write layout and attribute for file-level metadata
    meta.createAttribute("meta", vector<size_t>{YODA_H5_FORMAT_VERSION, aos.size()});
 
    // write error source labels
    (void)H5DataSet(h5, "labels", std::move(labels), _compress);
 
    // write bin edges
    for (const auto& item : layout) {
      item.second->writeToFile(item.first, h5, _compress);
    }
 
  }

References YODA::H5FileManager::AO_META, YODA::H5DataSet(), YODA::H5DataSetWriter< T >::writeSlice(), and YODA::YODA_H5_FORMAT_VERSION.

---

The documentation for this class was generated from the following files:

• include/YODA/WriterH5.h
• src/WriterH5.cc