Merge pull request #800 from UWB-Biocomputing/ShaikhDevelopment

Adding VertexType to Recorders

Author: zshaikh5

Simulator/Recorders/Hdf5Recorder.cpp

@@ -189,7 +189,22 @@ void Hdf5Recorder::compileHistories()
                } else if (variableInfo.hdf5Datatype_ == PredType::NATIVE_INT) {
                   vector<int> dataBuffer(variableInfo.variableLocation_.getNumElements());
                   for (size_t i = 0; i < variableInfo.variableLocation_.getNumElements(); ++i) {
-                     dataBuffer[i] = get<int>(variableInfo.variableLocation_.getElement(i));
+                     // For type int, a distinction needs to be made between vertexType and regular integers
+                     // Since vertexType is an enum class, it needs to first be converted to an integer before storing
+
+                     // 'decltype' determines the type at compile time
+                     // 'decay_t' removes any references/const from the type
+                     // This simplifies comparisons through 'is_same_v' to ensure type matches vertexType
+                     if (std::is_same_v<vertexType,
+                                        std::decay_t<decltype(get<vertexType>(
+                                           variableInfo.variableLocation_.getElement(i)))>>) {
+                        // If type matches vertexType, convert to int before storing
+                        dataBuffer[i] = static_cast<int>(
+                           get<vertexType>(variableInfo.variableLocation_.getElement(i)));
+                     } else {
+                        // Otherwise, store as a regular integer
+                        dataBuffer[i] = get<int>(variableInfo.variableLocation_.getElement(i));
+                     }
                   }
                   variableInfo.hdf5DataSet_.write(dataBuffer.data(), variableInfo.hdf5Datatype_,
                                                   memSpace, fileSpace);

Simulator/Recorders/Hdf5Recorder.h

@@ -114,6 +114,8 @@ class Hdf5Recorder : public Recorder {
             hdf5Datatype_ = PredType::NATIVE_FLOAT;
          } else if (dataType_ == typeid(double).name()) {
             hdf5Datatype_ = PredType::NATIVE_DOUBLE;
+         } else if (dataType_ == typeid(vertexType).name()) {
+            hdf5Datatype_ = PredType::NATIVE_INT;
          } else {
             throw runtime_error("Unsupported data type");
          }
@@ -136,7 +138,21 @@ class Hdf5Recorder : public Recorder {
             } else if (hdf5Datatype_ == PredType::NATIVE_INT) {
                vector<int> dataBuffer(variableLocation_.getNumElements());
                for (int i = 0; i < variableLocation_.getNumElements(); ++i) {
-                  dataBuffer[i] = get<int>(variableLocation_.getElement(i));
+                  // For type int, a distinction needs to be made between vertexType and regular integers
+                  // Since vertexType is an enum class, it needs to first be converted to an integer before storing
+
+                  // 'decltype' determines the type at compile time
+                  // 'decay_t' removes any references/const from the type
+                  // This simplifies comparisons through 'is_same_v' to ensure type matches vertexType
+                  if (std::is_same_v<vertexType, std::decay_t<decltype(get<vertexType>(
+                                                    variableLocation_.getElement(i)))>>) {
+                     // If type matches vertexType, convert to int before storing
+                     dataBuffer[i]
+                        = static_cast<int>(get<vertexType>(variableLocation_.getElement(i)));
+                  } else {
+                     // Otherwise, store as a regular integer
+                     dataBuffer[i] = get<int>(variableLocation_.getElement(i));
+                  }
                }
                hdf5DataSet_.write(dataBuffer.data(), hdf5Datatype_);
 

Simulator/Recorders/RecordableBase.h

@@ -14,6 +14,7 @@
 #pragma once
 
 using namespace std;
+#include "VertexType.h"
 #include <string>
 #include <typeinfo>
 #include <variant>
@@ -24,7 +25,7 @@ using namespace std;
 
 /// A list of pre-defined basic data types for variablse in all the simulations
 /// These pre-defined types should match with the types of variant in Recorder
-using variantTypes = variant<uint64_t, bool, int, BGFLOAT>;
+using variantTypes = variant<uint64_t, bool, int, BGFLOAT, vertexType>;
 
 class RecordableBase {
 public:

Simulator/Recorders/Recorder.h

@@ -19,14 +19,14 @@ using namespace std;
 
 
 /// a list of pre-defined basic data types in recorded variables
-using multipleTypes = variant<uint64_t, bool, int, BGFLOAT>;
+using multipleTypes = variant<uint64_t, bool, int, BGFLOAT, vertexType>;
 
 //TODO: remove it after implemtating the Hdf5Recorder
 class AllVertices;
 class Recorder {
 public:
    /// The recorded variable Type/Updated frequency
-   enum class UpdatedType {
+   enum UpdatedType {
       CONSTANT,   // value doesn't change in each epoch
       DYNAMIC     // value is updated in each peoch
       // Add more variable types as needed

Simulator/Recorders/XmlRecorder.cpp

@@ -115,6 +115,8 @@ string XmlRecorder::toXML(const string &name, vector<multipleTypes> &singleBuffe
          os << get<int>(element) << " ";
       } else if (basicType == typeid(BGFLOAT).name()) {
          os << get<BGFLOAT>(element) << " ";
+      } else if (basicType == typeid(vertexType).name()) {
+         os << static_cast<int>(get<vertexType>(element)) << " ";
       } else {
          perror("Error recording Recordable object");
          exit(EXIT_FAILURE);

Simulator/Utils/Global.h

@@ -8,6 +8,7 @@
 // Globally available functions and default parameter values.
 
 #pragma once
+#include "MTRand.h"
 
 // Debug output is included in both debug/release builds now.
 // The Default for debug is "LOW" and "OFF" for Release.
@@ -64,6 +65,7 @@ using uint64_t = unsigned long long int;   //included in inttypes.h, which is no
    //#include "Norm.h"
 #include "Coordinate.h"
 #include "VectorMatrix.h"
+#include "VertexType.h"
 
 using namespace std;
 
@@ -98,6 +100,8 @@ const int g_nMaxChunkSize = 100;
 // CALR: Caller radii
 // PSAP: PSAP nodes
 // EMS, FIRE, LAW: Responder nodes
+/* 
+// Moved to Utils/VertexType.h 
 enum class vertexType {
    // Neuro
    INH = 1,
@@ -117,6 +121,7 @@ inline std::ostream &operator<<(std::ostream &os, vertexType vT)
    os << static_cast<int>(vT);
    return os;
 }
+*/
 
 // Edge types.
 // NEURO:

Simulator/Utils/VertexType.h

@@ -0,0 +1,45 @@
+/**
+ * @file VertexType.h
+ *
+ * @ingroup Simulator/Utils
+ * 
+ * @brief Enum class of vertex types 
+ */
+
+// NETWORK MODEL VARIABLES NMV-BEGIN {
+// Vertex types.
+// NEURO:
+//	INH - Inhibitory neuron
+//	EXC - Excitory neuron
+// NG911:
+// CALR: Caller radii
+// PSAP: PSAP nodes
+// EMS, FIRE, LAW: Responder nodes
+
+#ifndef VERTEX_TYPE_H
+#define VERTEX_TYPE_H
+
+#include <ostream>
+
+enum class vertexType {
+   // Neuro
+   INH = 1,
+   EXC = 2,
+   // NG911
+   CALR = 3,
+   PSAP = 4,
+   EMS = 5,
+   FIRE = 6,
+   LAW = 7,
+   // UNDEF
+   VTYPE_UNDEF = 0
+};
+
+// Custom streaming operator<< for the enum class vertexType
+inline std::ostream &operator<<(std::ostream &os, vertexType vT)
+{
+   os << static_cast<int>(vT);
+   return os;
+}
+
+#endif   // VERTEX_TYPE_H

Testing/UnitTesting/Hdf5RecorderTests.cpp

@@ -95,6 +95,36 @@ TEST(Hdf5RecorderTest, RegisterVectorVariableTest)
    ASSERT_EQ(Recorder::UpdatedType::DYNAMIC, variableTable[1].variableType_);
 }
 
+// Unit test for registerVariable method with a vector of NeuronType enums
+TEST(Hdf5RecorderTest, RegisterVertexTypeTest)
+{
+   // Create an instance of Hdf5Recorder
+   std::string outputFile = "../Testing/UnitTesting/TestOutput/Hdf5test_output_register.h5";
+   Hdf5Recorder recorder(outputFile);
+   recorder.init();
+
+   // Create a vector of NeuronType enums
+   RecordableVector<vertexType> neuronTypes;
+   neuronTypes.resize(2);
+   neuronTypes[0] = vertexType::EXC;
+   neuronTypes[1] = vertexType::INH;
+
+   // register the vector of NeuronTypes
+   recorder.registerVariable("neuron_types", neuronTypes, Recorder::UpdatedType::DYNAMIC);
+
+   // Verify that the registered variables are stored correctly
+   const auto &variableTable = recorder.getVariableTable();
+   ASSERT_EQ(1, variableTable.size());   // Only one variable, "neuron_types"
+
+   // Verify that the registered variable name matches
+   ASSERT_EQ("neuron_types", variableTable[0].variableName_);
+   ASSERT_EQ(&neuronTypes, &variableTable[0].variableLocation_);
+
+   // Verify the type of update for this variable
+   ASSERT_EQ(Recorder::UpdatedType::DYNAMIC, variableTable[0].variableType_);
+}
+
+
 // Define the test case for saving simulation data
 TEST(Hdf5RecorderTest, SaveSimDataTest)
 {
@@ -139,6 +169,51 @@ TEST(Hdf5RecorderTest, SaveSimDataTest)
    }
 }
 
+// Unit test for saving simulation data with a vector of NeuronType enums
+TEST(Hdf5RecorderTest, SaveSimDataVertexTypeTest)
+{
+   // Define a temporary file path for testing
+   std::string outputFile = "../Testing/UnitTesting/TestOutput/Hdf5test_output_save.h5";
+
+   // Create an instance of Hdf5Recorder
+   Hdf5Recorder recorder(outputFile);
+   recorder.init();
+
+   // Create and configure RecordableVector<vertexType> for testing
+   RecordableVector<vertexType> neuronTypes;
+   neuronTypes.resize(3);
+   neuronTypes[0] = vertexType::EXC;
+   neuronTypes[1] = vertexType::INH;
+   neuronTypes[2] = vertexType::EXC;
+
+   // Register the variable with Hdf5Recorder
+   recorder.registerVariable("neuron_types", neuronTypes, Recorder::UpdatedType::CONSTANT);
+
+   // Call saveSimData() to write the data to the file
+   recorder.saveSimData();
+
+   // Open the HDF5 file and read back the data
+   H5File file(outputFile, H5F_ACC_RDONLY);
+   DataSet dataset = file.openDataSet("neuron_types");
+   DataSpace dataspace = dataset.getSpace();
+
+   hsize_t num_elements;
+   dataspace.getSimpleExtentDims(&num_elements, nullptr);
+
+   // Read the data into a buffer
+   vector<int> dataBuffer(num_elements);
+   dataset.read(dataBuffer.data(), PredType::NATIVE_INT);
+
+   // Verify the data matches the expected NeuronType values (converted to int)
+   vector<int> expectedData = {static_cast<int>(vertexType::EXC), static_cast<int>(vertexType::INH),
+                               static_cast<int>(vertexType::EXC)};
+
+   ASSERT_EQ(expectedData.size(), dataBuffer.size());
+   for (size_t i = 0; i < expectedData.size(); ++i) {
+      EXPECT_EQ(expectedData[i], dataBuffer[i]);
+   }
+}
+
 // Define the test case for compiling histories
 TEST(Hdf5RecorderTest, CompileHistoriesTest)
 {
@@ -190,4 +265,64 @@ TEST(Hdf5RecorderTest, CompileHistoriesTest)
    }
 }
 
+// Define the test case for compiling histories with vertexType enum
+TEST(Hdf5RecorderTest, CompileHistoriesVertexTypeTest)
+{
+   // Define temporary file path for testing
+   std::string outputFile
+      = "../Testing/UnitTesting/TestOutput/Hdf5test_output_compile_histories_neuron_type.h5";
+
+   // Create an instance of Hdf5Recorder
+   Hdf5Recorder recorder(outputFile);
+   recorder.init();
+
+   // Create and configure EventBuffer for testing (stored as int)
+   EventBuffer eventBufferNeuron(5);
+
+   // Register the variable with Hdf5Recorder as DYNAMIC
+   recorder.registerVariable("neuron_types", eventBufferNeuron, Recorder::UpdatedType::DYNAMIC);
+
+   // Expected values for checking correctness
+   std::vector<int> expectedData;
+
+   // Call compileHistories() multiple times to simulate multiple epochs
+   for (int epoch = 0; epoch < 3; ++epoch) {
+      // Clear and insert new NeuronType values
+      eventBufferNeuron.clear();
+      eventBufferNeuron.insertEvent(static_cast<int>(vertexType::EXC));
+      eventBufferNeuron.insertEvent(static_cast<int>(vertexType::INH));
+      eventBufferNeuron.insertEvent(static_cast<int>(vertexType::EXC));
+      eventBufferNeuron.insertEvent(static_cast<int>(vertexType::EXC));
+      eventBufferNeuron.insertEvent(static_cast<int>(vertexType::INH));
+
+      // Append expected values for this epoch
+      expectedData.push_back(static_cast<int>(vertexType::EXC));
+      expectedData.push_back(static_cast<int>(vertexType::INH));
+      expectedData.push_back(static_cast<int>(vertexType::EXC));
+      expectedData.push_back(static_cast<int>(vertexType::EXC));
+      expectedData.push_back(static_cast<int>(vertexType::INH));
+
+      // Call compile history
+      recorder.compileHistories();
+   }
+
+   // Open the HDF5 file and read back the data
+   H5File file(outputFile, H5F_ACC_RDONLY);
+   DataSet dataset = file.openDataSet("neuron_types");
+   DataSpace dataspace = dataset.getSpace();
+
+   hsize_t num_elements;
+   dataspace.getSimpleExtentDims(&num_elements, nullptr);
+
+   std::vector<int> dataBuffer(num_elements);
+   dataset.read(dataBuffer.data(), PredType::NATIVE_INT);
+
+   // Ensure data size matches expectation
+   ASSERT_EQ(expectedData.size(), dataBuffer.size());
+
+   // Verify that stored values match expected values
+   for (size_t i = 0; i < expectedData.size(); ++i) {
+      EXPECT_EQ(expectedData[i], dataBuffer[i]);
+   }
+}
 #endif   // HDF5