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"
#include "spec/core.hpp"
 
namespace AQNWB::NWB
{
class TimeSeries : public Container
{
public:
  // Register the TimeSeries as a subclass of Container
  REGISTER_SUBCLASS(TimeSeries, AQNWB::SPEC::CORE::namespaceName)
 
  
  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::ArrayDataSetConfig& dataConfig,
                  const std::string& unit,
                  const std::string& description = "no description",
                  const std::string& comments = "no comments",
                  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 = {});

  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_ATTRIBUTE_FIELD(readDescription,
                         std::string,
                         "description",
                         Description of the series)
 
  DEFINE_ATTRIBUTE_FIELD(readComments,
                         std::string,
                         "comments",
                         Human - readable comments about the TimeSeries)
 
  DEFINE_DATASET_FIELD(readData, recordData, std::any, "data", The main data)
 
  DEFINE_ATTRIBUTE_FIELD(readDataConversion,
                         float,
                         "data/conversion",
                         Scalar to multiply each element in data to convert it
                             to the specified unit)
 
  DEFINE_ATTRIBUTE_FIELD(readDataOffset,
                         float,
                         "data/offset",
                         Scalar to add to the data after scaling by conversion
                             to finalize its coercion to the specified unit)
 
  DEFINE_ATTRIBUTE_FIELD(readDataResolution,
                         float,
                         "data/resolution",
                         Smallest meaningful difference between values in data)
 
  DEFINE_ATTRIBUTE_FIELD(readDataUnit,
                        std::string,
                        "data/unit",
                        Base unit of measurement for working with the data)
 
  DEFINE_ATTRIBUTE_FIELD(readDataContinuity,
                         std::string,
                         "data/continuity",
                         Continuity of the data)
 
  DEFINE_DATASET_FIELD(readStartingTime,
                       recordStartingTime,
                       double,
                       "starting_time",
                       Timestamp of the first sample in seconds)
 
  DEFINE_ATTRIBUTE_FIELD(readStartingTimeRate,
                         float,
                         "starting_time/rate",
                         Sampling rate in Hz)
 
  DEFINE_ATTRIBUTE_FIELD(readStartingTimeUnit,
                         std::string,
                         "starting_time/unit",
                         Unit of measurement for time fixed to seconds)
 
  DEFINE_DATASET_FIELD(readTimestamps,
                       recordTimestamps,
                       double,
                       "timestamps",
                       Timestamps offset in seconds relative to the master time for samples stored in data)
 
  DEFINE_ATTRIBUTE_FIELD(readTimestampsInterval,
                         int,
                         "timestamps/interval",
                         Interval value is 1)
 
  DEFINE_ATTRIBUTE_FIELD(readTimestampsUnit,
                         std::string,
                         "timestamps/unit",
                         Unit of measurement for timestamps fixed to seconds)
 
  DEFINE_DATASET_FIELD(readControl,
                       recordControl,
                       uint8_t,
                       "control",
                       Numerical labels that apply to each time point in data)
 
  DEFINE_DATASET_FIELD(readControlDescription,
                       recordControlDescription,
                       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