Fix ElectricalSeries->electrodes dataset write and add tests

src/nwb/ecephys/ElectricalSeries.cpp

@@ -43,10 +43,10 @@ void ElectricalSeries::initialize(const IO::BaseDataType& dataType,
   this->m_channelVector = channelVector;
 
   // setup variables based on number of channels
-  std::vector<SizeType> electrodeInds(channelVector.size());
+  std::vector<int> electrodeInds(channelVector.size());
   std::vector<float> channelConversions(channelVector.size());
   for (size_t i = 0; i < channelVector.size(); ++i) {
-    electrodeInds[i] = channelVector[i].getGlobalIndex();
+    electrodeInds[i] = static_cast<int>(channelVector[i].getGlobalIndex());
     channelConversions[i] = channelVector[i].getConversion();
   }
   m_samplesRecorded = SizeArray(channelVector.size(), 0);
@@ -73,14 +73,13 @@ void ElectricalSeries::initialize(const IO::BaseDataType& dataType,
   // make electrodes dataset
   m_electrodesDataset = std::unique_ptr<IO::BaseRecordingData>(
       m_io->createArrayDataSet(IO::BaseDataType::I32,
-                               SizeArray {1},
+                               SizeArray {channelVector.size()},
                                chunkSize,
                                AQNWB::mergePaths(getPath(), "electrodes")));
 
-  m_electrodesDataset->writeDataBlock(
-      std::vector<SizeType>(1, channelVector.size()),
-      IO::BaseDataType::I32,
-      &electrodeInds[0]);
+  m_electrodesDataset->writeDataBlock(SizeArray {channelVector.size()},
+                                      IO::BaseDataType::I32,
+                                      &electrodeInds[0]);
   auto electrodesPath = AQNWB::mergePaths(getPath(), "electrodes");
   m_io->createCommonNWBAttributes(
       electrodesPath, "hdmf-common", "DynamicTableRegion");

src/nwb/ecephys/ElectricalSeries.hpp

@@ -109,6 +109,17 @@ class ElectricalSeries : public TimeSeries
                Base unit of measurement for working with the data. 
                This value is fixed to volts)
 
+  DEFINE_FIELD(readElectrodes,
+               DatasetField,
+               int,
+               "electrodes",
+               The electrodes that generated this electrical series.)
+
+  DEFINE_FIELD(readElectrodesDescription,
+               AttributeField,
+               std::string,
+               "electrodes/description",
+               The electrodes that generated this electrical series.)
 private:
   /**
    * @brief The number of samples already written per channel.

tests/testEcephys.cpp

@@ -7,6 +7,7 @@
 #include "Utils.hpp"
 #include "io/BaseIO.hpp"
 #include "io/hdf5/HDF5IO.hpp"
+#include "nwb/RegisteredType.hpp"
 #include "nwb/device/Device.hpp"
 #include "nwb/ecephys/ElectricalSeries.hpp"
 #include "nwb/ecephys/SpikeEventSeries.hpp"
@@ -187,6 +188,67 @@ TEST_CASE("ElectricalSeries", "[ecephys]")
     REQUIRE_THAT(dataOut[0], Catch::Matchers::Approx(mockData[0]).margin(1));
     REQUIRE_THAT(dataOut[1], Catch::Matchers::Approx(mockData[1]).margin(1));
   }
+
+  SECTION("test writing electrodes")
+  {
+    std::vector<Types::ChannelVector> mockArraysElectrodes =
+        getMockChannelArrays(4);
+
+    // setup io object
+    std::string path = getTestFilePath("ElectricalSeriesElectrodes.h5");
+    std::shared_ptr<BaseIO> io = createIO("HDF5", path);
+    io->open();
+    io->createGroup("/general");
+    io->createGroup("/general/extracellular_ephys");
+
+    // setup device and electrode group
+    auto device = NWB::Device(devicePath, io);
+    device.initialize("description", "unknown");
+    auto elecGroup = NWB::ElectrodeGroup(electrodePath, io);
+    elecGroup.initialize("description", "unknown", device);
+
+    // setup electrode table
+    NWB::ElectrodeTable elecTable = NWB::ElectrodeTable(io);
+    elecTable.initialize();
+    elecTable.addElectrodes(mockArraysElectrodes[0]);
+    elecTable.finalize();
+
+    // setup electrical series
+    NWB::ElectricalSeries es = NWB::ElectricalSeries(dataPath, io);
+    es.initialize(BaseDataType::F32,
+                  mockArraysElectrodes[0],
+                  "no description",
+                  SizeArray {0, mockArrays[0].size()},
+                  SizeArray {1, 1});
+    io->close();
+
+    // // read the data back in
+    io = createIO("HDF5", path);
+    io->open();
+
+    // Verify electrodes dataset exists and contains correct data
+    auto readElectricalSeries =
+        NWB::RegisteredType::create<NWB::ElectricalSeries>(dataPath, io);
+    auto readElectrodesWrapper = readElectricalSeries->readElectrodes();
+    auto readElectrodesValues = readElectrodesWrapper->values();
+    for (size_t i = 0; i < mockArraysElectrodes[0].size(); ++i) {
+      REQUIRE(static_cast<SizeType>(readElectrodesValues.data[i])
+              == mockArraysElectrodes[0][i].getGlobalIndex());
+    }
+
+    // Verify dataset attributes
+    auto readElectrodesDescriptionWrapper =
+        readElectricalSeries->readElectrodesDescription();
+    auto readElectrodesDescriptionValues =
+        readElectrodesDescriptionWrapper->values().data[0];
+    REQUIRE(readElectrodesDescriptionValues
+            == "the electrodes that generated this electrical series");
+
+    // TODO - add test for reading when references are supported in read
+    // auto readElectrodesTableWrapper =
+    // readElectricalSeries->readElectrodesTable(); auto
+    // readElectrodesTableValues = readElectrodesTableWrapper->values().data[0];
+  }
 }
 
 TEST_CASE("SpikeEventSeries", "[ecephys]")
@@ -338,4 +400,4 @@ TEST_CASE("SpikeEventSeries", "[ecephys]")
     REQUIRE_THAT(dataOut[0], Catch::Matchers::Approx(mockData[0]).margin(1));
     REQUIRE_THAT(dataOut[1], Catch::Matchers::Approx(mockData[1]).margin(1));
   }
-}
+}