report_reader.h

#pragma once
 
#include <map>
#include <string>
#include <utility>
#include <vector>
 
#include <highfive/H5File.hpp>
 
#include <bbp/sonata/optional.hpp>
#include <bbp/sonata/population.h>
 
namespace bbp {
namespace sonata {
 
// KeyType will be NodeID for somas report and CompartmentID for elements report
template <typename KeyType>
struct SONATA_API DataFrame {
    using DataType = std::vector<KeyType>;
    std::vector<double> times;
    DataType ids;
    // data[times][ids], flattened. n_cols is ids.size()
    std::vector<float> data;
};
 
using Spike = std::pair<NodeID, double>;
using Spikes = std::vector<Spike>;
struct SpikeTimes {
    std::vector<NodeID> node_ids;
    std::vector<double> timestamps;
};
 
class SONATA_API SpikeReader
{
  public:
    class Population
    {
      public:
        enum class Sorting : char {
            none = 0,
            by_id = 1,
            by_time = 2,
        };
 
        std::tuple<double, double> getTimes() const;
 
        Spikes get(const nonstd::optional<Selection>& node_ids = nonstd::nullopt,
                   const nonstd::optional<double>& tstart = nonstd::nullopt,
                   const nonstd::optional<double>& tstop = nonstd::nullopt) const;
 
        const SpikeTimes& getRawArrays() const;
 
        SpikeTimes getArrays(const nonstd::optional<Selection>& node_ids = nonstd::nullopt,
                             const nonstd::optional<double>& tstart = nonstd::nullopt,
                             const nonstd::optional<double>& tstop = nonstd::nullopt) const;
 
        Sorting getSorting() const;
 
      private:
        Population(const std::string& filename, const std::string& populationName);
 
        SpikeTimes spike_times_;
        Sorting sorting_ = Sorting::none;
        // Use for clamping of user values
        double tstart_, tstop_;
 
        void filterNode(Spikes& spikes, const Selection& node_ids) const;
        void filterTimestamp(Spikes& spikes, double tstart, double tstop) const;
        Spikes createSpikes() const;
 
        friend SpikeReader;
    };
 
    explicit SpikeReader(std::string filename);
 
    std::vector<std::string> getPopulationNames() const;
 
    const Population& openPopulation(const std::string& populationName) const;
 
  private:
    std::string filename_;
 
    // Lazy loaded population
    mutable std::map<std::string, Population> populations_;
};
 
template <typename KeyType>
class SONATA_API ReportReader
{
  public:
    class Population
    {
      public:
        std::tuple<double, double, double> getTimes() const;
 
        std::string getTimeUnits() const;
 
        std::string getDataUnits() const;
 
        bool getSorted() const;
 
        std::vector<NodeID> getNodeIds() const;
 
        typename DataFrame<KeyType>::DataType getNodeIdElementIdMapping(
            const nonstd::optional<Selection>& node_ids = nonstd::nullopt,
            const nonstd::optional<size_t>& block_gap_limit = nonstd::nullopt) const;
 
        DataFrame<KeyType> get(
            const nonstd::optional<Selection>& node_ids = nonstd::nullopt,
            const nonstd::optional<double>& tstart = nonstd::nullopt,
            const nonstd::optional<double>& tstop = nonstd::nullopt,
            const nonstd::optional<size_t>& tstride = nonstd::nullopt,
            const nonstd::optional<size_t>& block_gap_limit = nonstd::nullopt) const;
 
      private:
        struct NodeIdElementLayout {
            typename DataFrame<KeyType>::DataType ids;
            Selection::Ranges node_ranges;
            std::vector<uint64_t> node_offsets;
            std::vector<uint64_t> node_index;
            Selection::Ranges min_max_blocks;
        };
 
        Population(const HighFive::File& file, const std::string& populationName);
        std::pair<size_t, size_t> getIndex(const nonstd::optional<double>& tstart,
                                           const nonstd::optional<double>& tstop) const;
        NodeIdElementLayout getNodeIdElementLayout(
            const nonstd::optional<Selection>& node_ids = nonstd::nullopt,
            const nonstd::optional<size_t>& block_gap_limit = nonstd::nullopt) const;
 
        HighFive::Group pop_group_;
        std::vector<NodeID> node_ids_;
        std::vector<Selection::Range> node_ranges_;
        std::vector<uint64_t> node_offsets_;
        std::vector<uint64_t> node_index_;
        double tstart_, tstop_, tstep_;
        std::vector<std::pair<size_t, double>> times_index_;
        std::string time_units_;
        std::string data_units_;
        bool is_node_ids_sorted_;
 
        friend ReportReader;
    };
 
    explicit ReportReader(const std::string& filename);
 
    std::vector<std::string> getPopulationNames() const;
 
    const Population& openPopulation(const std::string& populationName) const;
 
  private:
    HighFive::File file_;
 
    // Lazy loaded population
    mutable std::map<std::string, Population> populations_;
};
 
using SomaReportReader = ReportReader<NodeID>;
using ElementReportReader = ReportReader<CompartmentID>;
 
}  // namespace sonata
}  // namespace bbp