TimeSeries.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <string>
 
#include "Utils.hpp"
#include "io/BaseIO.hpp"
#include "io/ReadIO.hpp"
#include "nwb/hdmf/base/Container.hpp"
 
namespace AQNWB::NWB
{
class TimeSeries : public Container
{
public:
  // Register the TimeSeries as a subclass of Container
  REGISTER_SUBCLASS(TimeSeries, "core")
 
  
  enum ContinuityType
  {
    Continuous = 0,
    Instantaneous = 1,
    Step = 2,
    Undefined = -1
  };

  static std::map<ContinuityType, std::string> ContinuityTypeNames;

  TimeSeries(const std::string& path, std::shared_ptr<IO::BaseIO> io);

  ~TimeSeries();

  Status writeData(const std::vector<SizeType>& dataShape,
                   const std::vector<SizeType>& positionOffset,
                   const void* dataInput,
                   const void* timestampsInput = nullptr,
                   const void* controlInput = nullptr);

  void initialize(const IO::BaseDataType& dataType,
                  const std::string& unit,
                  const std::string& description = "no description",
                  const std::string& comments = "no comments",
                  const SizeArray& dsetSize = SizeArray {0},
                  const SizeArray& chunkSize = SizeArray {1},
                  const float& conversion = 1.0f,
                  const float& resolution = -1.0f,
                  const float& offset = 0.0f,
                  const ContinuityType& continuity = ContinuityType::Undefined,
                  const double& startingTime = -1.0,
                  const float& startingTimeRate = 1.0f,
                  const std::vector<std::string>& controlDescription = {});

  std::unique_ptr<IO::BaseRecordingData> data;

  std::unique_ptr<IO::BaseRecordingData> timestamps;

  std::unique_ptr<IO::BaseRecordingData> starting_time;

  std::unique_ptr<IO::BaseRecordingData> control;

  std::unique_ptr<IO::BaseRecordingData> control_description;

  IO::BaseDataType m_dataType;

  IO::BaseDataType timestampsType = IO::BaseDataType::F64;

  IO::BaseDataType controlType = IO::BaseDataType::U8;
 
  // Define the data fields to expose for lazy read access
  DEFINE_FIELD(readDescription,
               AttributeField,
               std::string,
               "description",
               Description of the series)
 
  DEFINE_FIELD(readComments,
               AttributeField,
               std::string,
               "comments",
               Human - readable comments about the TimeSeries)
 
  DEFINE_FIELD(readData, DatasetField, std::any, "data", The main data)
 
  DEFINE_FIELD(readDataConversion,
               AttributeField,
               float,
               "data/conversion",
               Scalar to multiply each element in data to convert it to the
                   specified unit)
 
  DEFINE_FIELD(readDataOffset,
               AttributeField,
               float,
               "data/offset",
               Scalar to add to the data after scaling by conversion to finalize
                   its coercion to the specified unit)
 
  DEFINE_FIELD(readDataResolution,
               AttributeField,
               float,
               "data/resolution",
               Smallest meaningful difference between values in data)
 
  DEFINE_FIELD(readDataUnit,
               AttributeField,
               std::string,
               "data/unit",
               Base unit of measurement for working with the data)
 
  DEFINE_FIELD(readDataContinuity,
               AttributeField,
               std::string,
               "data/continuity",
               Continuity of the data)
 
  DEFINE_FIELD(readStartingTime,
               DatasetField,
               double,
               "starting_time",
               Timestamp of the first sample in seconds)
 
  DEFINE_FIELD(readStartingTimeRate,
               AttributeField,
               float,
               "starting_time/rate",
               Sampling rate in Hz)
 
  DEFINE_FIELD(readStartingTimeUnit,
               AttributeField,
               std::string,
               "starting_time/unit",
               Unit of measurement for time fixed to seconds)
 
  DEFINE_FIELD(readTimestamps,
               DatasetField,
               double,
               "timestamps",
               Timestamps offset in seconds relative to the master time for samples stored in data)
 
  DEFINE_FIELD(readTimestampsInterval,
               AttributeField,
               int,
               "timestamps/interval",
               Interval value is 1)
 
  DEFINE_FIELD(readTimestampsUnit,
               AttributeField,
               std::string,
               "timestamps/unit",
               Unit of measurement for timestamps fixed to seconds)
 
  DEFINE_FIELD(readControl,
               DatasetField,
               uint8_t,
               "control",
               Numerical labels that apply to each time point in data)
 
  DEFINE_FIELD(readControlDescription,
               DatasetField,
               std::string,
               "control_description",
               Description of each control value)
 
private:
  Status createTimestampsAttributes(const std::string& path);

  Status createDataAttributes(const std::string& path,
                              const float& conversion,
                              const float& resolution,
                              const float& offset,
                              const std::string& unit,
                              const ContinuityType& continuity);
};
}  // namespace AQNWB::NWB