[issue-779] Populate STDP edge recorder output

CMakeLists.txt

@@ -484,6 +484,7 @@ add_executable(tests
         Testing/UnitTesting/OperationManagerTestingClass.h
         Testing/UnitTesting/VerticesFactoryTests.cpp
         Testing/UnitTesting/ConnectionsFactoryTests.cpp
+        Testing/UnitTesting/ConnStaticTests.cpp
         Testing/UnitTesting/EdgesFactoryTests.cpp
         Testing/UnitTesting/LayoutFactoryTests.cpp
         Testing/UnitTesting/RecorderFactoryTests.cpp

Simulator/Connections/Neuro/ConnStatic.cpp

@@ -93,11 +93,36 @@ void ConnStatic::printParameters() const
 void ConnStatic::registerHistoryVariables()
 {
    // Register the following variables to be recorded
-   // Note: There may be potential duplicate weight, source, destination vertices
    Recorder &recorder = Simulator::getInstance().getModel().getRecorder();
    recorder.registerVariable("weight", WCurrentEpoch_, Recorder::UpdatedType::DYNAMIC);
    recorder.registerVariable("sourceVertex", sourceVertexIndexCurrentEpoch_,
                              Recorder::UpdatedType::DYNAMIC);
    recorder.registerVariable("destinationVertex", destVertexIndexCurrentEpoch_,
                              Recorder::UpdatedType::DYNAMIC);
 }
+
+bool ConnStatic::updateConnections()
+{
+   // GPU STDP is not implemented, so this only uses the CPU edge data.
+   WCurrentEpoch_.startNewEpoch();
+   sourceVertexIndexCurrentEpoch_.startNewEpoch();
+   destVertexIndexCurrentEpoch_.startNewEpoch();
+
+   AllEdges &edges = getEdges();
+   const vector<unsigned char> &inUse = edges.getInUse();
+   const vector<BGFLOAT> &weights = edges.getWeights();
+   const vector<int> &sourceVertices = edges.getSourceVertexIndices();
+   const vector<int> &destVertices = edges.getDestVertexIndices();
+
+   // Copy one value per active edge into parallel recorder vectors.
+   // Entries at the same index describe the same edge.
+   for (BGSIZE iEdg = 0; iEdg < inUse.size(); iEdg++) {
+      if (inUse[iEdg]) {
+         WCurrentEpoch_.push_back(weights[iEdg]);
+         sourceVertexIndexCurrentEpoch_.push_back(sourceVertices[iEdg]);
+         destVertexIndexCurrentEpoch_.push_back(destVertices[iEdg]);
+      }
+   }
+
+   return false;
+}

Simulator/Connections/Neuro/ConnStatic.h

@@ -64,6 +64,9 @@ class ConnStatic : public Connections {
    /// Registers history variables for recording during simulation
    virtual void registerHistoryVariables() override;
 
+   /// Populates edge history variables for recording during the current epoch.
+   virtual bool updateConnections() override;
+
    /// Get array of vertex weights
    const vector<BGFLOAT> &getWCurrentEpoch() const
    {

Simulator/Edges/AllEdges.h

@@ -59,6 +59,30 @@ class AllEdges {
    ///  Populate a edge index map.
    virtual void createEdgeIndexMap(EdgeIndexMap &edgeIndexMap);
 
+   /// Get array of source vertex indices.
+   const vector<int> &getSourceVertexIndices() const
+   {
+      return sourceVertexIndex_;
+   }
+
+   /// Get array of destination vertex indices.
+   const vector<int> &getDestVertexIndices() const
+   {
+      return destVertexIndex_;
+   }
+
+   /// Get array of edge weights.
+   const vector<BGFLOAT> &getWeights() const
+   {
+      return W_;
+   }
+
+   /// Get array of active edge flags.
+   const vector<unsigned char> &getInUse() const
+   {
+      return inUse_;
+   }
+
    ///  Cereal serialization method
    template <class Archive> void serialize(Archive &archive);
 
@@ -253,4 +277,4 @@ template <class Archive> void AllEdges::serialize(Archive &archive)
            cereal::make_nvp("totalEdgeCount", totalEdgeCount_),
            cereal::make_nvp("maxEdgesPerVertex", maxEdgesPerVertex_),
            cereal::make_nvp("countVertices", countVertices_));
-}
+}

Testing/UnitTesting/ConnStaticTests.cpp

@@ -0,0 +1,51 @@
+/**
+ * @file ConnStaticTests.cpp
+ *
+ * @brief Unit tests for ConnStatic.
+ *
+ * @ingroup Testing/UnitTesting
+ */
+
+#include "AllSTDPSynapses.h"
+#include "ConnStatic.h"
+#include "gtest/gtest.h"
+#include <memory>
+#include <vector>
+
+namespace {
+
+   class TestConnStatic : public ConnStatic {
+   public:
+      void setEdges(std::unique_ptr<AllEdges> edges)
+      {
+         edges_ = std::move(edges);
+      }
+   };
+
+   TEST(ConnStatic, UpdateConnectionsCopiesActiveEdgesWithoutAccumulating)
+   {
+      auto edges = std::make_unique<AllSTDPSynapses>(3, 2);
+      edges->addEdge(edgeType::EE, 0, 2, 0.001);
+      edges->addEdge(edgeType::II, 2, 0, 0.001);
+
+      const std::vector<int> expectedSources {2, 0};
+      const std::vector<int> expectedDestinations {0, 2};
+      const std::vector<BGFLOAT> expectedWeights {-10.0e-9, 10.0e-9};
+
+      TestConnStatic connections;
+      connections.setEdges(std::move(edges));
+
+      connections.updateConnections();
+
+      EXPECT_EQ(expectedSources, connections.getSourceVertexIndexCurrentEpoch());
+      EXPECT_EQ(expectedDestinations, connections.getDestVertexIndexCurrentEpoch());
+      EXPECT_EQ(expectedWeights, connections.getWCurrentEpoch());
+
+      connections.updateConnections();
+
+      EXPECT_EQ(expectedSources, connections.getSourceVertexIndexCurrentEpoch());
+      EXPECT_EQ(expectedDestinations, connections.getDestVertexIndexCurrentEpoch());
+      EXPECT_EQ(expectedWeights, connections.getWCurrentEpoch());
+   }
+
+}   // namespace