EventsTable.hpp

Go to the documentation of this file.

#pragma once
 
// Common STL includes
#include <memory>
#include <optional>
#include <string>
#include <vector>
// Base AqNWB includes for IO and RegisteredType
#include "io/BaseIO.hpp"
#include "io/ReadIO.hpp"
#include "nwb/RegisteredType.hpp"
// Include for parent type
#include "nwb/event/DurationVectorData.hpp"
#include "nwb/event/TimestampVectorData.hpp"
#include "nwb/hdmf/table/DynamicTable.hpp"
 
// Include for the namespace schema header
#include "spec/core.hpp"
 
namespace AQNWB::NWB
{

class EventsTable : public AQNWB::NWB::DynamicTable
{
public:
  virtual ~EventsTable() override {}

  Status validateDataSpecs(
      const std::vector<DataSpecPtr>& dataSpecs) const override;

  static std::vector<DataSpecPtr> createDefaultDataSpecs(
      std::optional<float> timestampResolution = std::nullopt,
      bool createDurationColumn = false,
      std::optional<float> durationResolution = std::nullopt,
      const bool createAnnotationColumn = false,
      const SizeType rowChunkSize = 100);

  Status initialize(
      const std::string& description,
      const std::optional<std::string>& sourceDescription = std::nullopt,
      const std::vector<DataSpecPtr>& columnSpecs = {});
 
  // Define read methods
  // description overrides inherited field from parent neurodata_type
  DEFINE_ATTRIBUTE_FIELD(
      readDescription,
      std::string,
      "description",
      "A description of the events stored in the table - including information "
      "about how the event times were computed - especially if the times are "
      "the result of processing or filtering raw data. For example - if the "
      "experimenter is encoding different types of events using a strobed or "
      "N-bit encoding - then the description should describe which channels "
      "were used and how the event time is computed - e.g. - as the rise time "
      "of the first bit.")
 
  DEFINE_ATTRIBUTE_FIELD(
      readSourceDescription,
      std::string,
      "source_description",
      "Optional short text description of where the events came from - "
      "applying to every row in the table. For example - Acquisition system "
      "for events emitted directly by the acquisition system (e.g. - TTL edges "
      "or hardware event channels); Thresholding of analog signal ANALOG1 at 3 "
      "V for events produced by a detection algorithm run on acquired data; or "
      "Manual video review for events added by a human annotator. This is a "
      "free-text label of origin only; use `description` for the longer "
      "narrative of how the event times were computed (channels used - "
      "encoding scheme - algorithm parameters - etc.).")
 
  DEFINE_REGISTERED_FIELD(readTimestampColumn,
                          AQNWB::NWB::TimestampVectorData,
                          "timestamp",
                          "Column containing the time that each event occurred "
                          "- in seconds - from the session start time.")
 
  DEFINE_REGISTERED_FIELD(
      readDurationColumn,
      AQNWB::NWB::DurationVectorData,
      "duration",
      "Optional column containing the duration of each event - in seconds. A "
      "value of NaN can be used for events without a duration or with a "
      "duration that is not yet specified.")
 
  DEFINE_REGISTERED_FIELD(readAnnotationColumn,
                          AQNWB::NWB::VectorData,
                          "annotation",
                          "Column containing user annotations about events.")
 
  REGISTER_SUBCLASS(EventsTable, DynamicTable, AQNWB::SPEC::CORE::namespaceName)
 
protected:
  EventsTable(const std::string& path, std::shared_ptr<AQNWB::IO::BaseIO> io);
};
 
}  // namespace AQNWB::NWB