Merge pull request #678 from UWB-Biocomputing/issue-656-add-registerVariableForHdf5Recorder

implement registerVariable in Hdf5 Recorder

Author: Hsu0227

Simulator/Recorders/Hdf5Recorder.cpp

@@ -49,7 +49,6 @@ void Hdf5Recorder::init()
    if ((resultFileName_.size() <= suffix.size())
        || (resultFileName_.compare(resultFileName_.size() - suffix.size(), suffix.size(), suffix)
            != 0)) {
-      //perror("the file extention is not .h5 ");
       string errorMsg
          = "Error: the file extension is not .h5. Provided file name: " + resultFileName_;
       perror(errorMsg.c_str());
@@ -108,4 +107,22 @@ void Hdf5Recorder::term()
 void Hdf5Recorder::initDataSet()
 {
 }
+
+/// Receives a recorded variable entity from the variable owner class
+/// used when the return type from recordable variable is supported by Recorder
+/**
+* @brief Registers a single instance of a class derived from RecordableBase.
+* @param varName Name of the recorded variable.
+* @param recordVar Reference to the recorded variable.
+* @param variableType Type of the recorded variable.
+*/
+void Hdf5Recorder::registerVariable(const string &varName, RecordableBase &recordVar,
+                                    UpdatedType variableType)
+{
+   // Create a singleVariableInfo object for the variable
+   singleVariableInfo hdf5VarInfo(varName, recordVar, variableType);
+
+   // Add the variable information to the variableTable_
+   variableTable_.push_back(hdf5VarInfo);
+}
 #endif   // HDF5

Simulator/Recorders/Hdf5Recorder.h

@@ -85,16 +85,76 @@ class Hdf5Recorder : public Recorder {
    * @param variableType Type of the recorded variable.
    */
    virtual void registerVariable(const string &varName, RecordableBase &recordVar,
-                                 UpdatedType variableType) override
-   {
-   }
+                                 UpdatedType variableType) override;
 
    /// Register a vector of instance of a class derived from RecordableBase.
    virtual void registerVariable(const string &varName, vector<RecordableBase *> &recordVars,
                                  UpdatedType variableType) override
    {
    }
 
+   struct singleVariableInfo {
+      /// the name of each variable
+      string variableName_;
+
+      /// the basic data type in the Recorded variable
+      string dataType_;
+
+      /// the data type in Hdf5 file
+      DataType hdf5Datatype_;
+
+      /// the data set for Hdf5 file
+      DataSet hdf5DataSet_;
+
+      /// the variable type: updated frequency
+      UpdatedType variableType_;
+
+      /// a reference to a RecordableBase variable
+      /// As the simulator runs, the values in the RecordableBase object will be updated
+      RecordableBase &variableLocation_;
+
+      // Constructor accepting the variable name, the address of recorded variable, the updated type
+      singleVariableInfo(const string &name, RecordableBase &location, UpdatedType variableType) :
+         variableLocation_(location), variableName_(name), variableType_(variableType)
+      {
+         dataType_ = location.getDataType();
+         convertType();
+      }
+
+      // Converts the data type of the variable to HDF5 data type
+      void convertType()
+      {
+         if (dataType_ == typeid(uint64_t).name()) {
+            hdf5Datatype_ = PredType::NATIVE_UINT64;
+         } else if (dataType_ == typeid(bool).name()) {
+            hdf5Datatype_ = PredType::NATIVE_UINT8;
+         } else if (dataType_ == typeid(int).name()) {
+            hdf5Datatype_ = PredType::NATIVE_INT;
+         } else if (dataType_ == typeid(float).name()) {
+            hdf5Datatype_ = PredType::NATIVE_FLOAT;
+         } else if (dataType_ == typeid(double).name()) {
+            hdf5Datatype_ = PredType::NATIVE_DOUBLE;
+         } else {
+            //string errorMsg = "Not supported type for type: " + dataType_;
+            throw runtime_error("Unsupported data type");
+         }
+      }
+
+      // Creates a dynamic dataset in the HDF5 file
+      void createDynamicDataset(H5File *resultOut_)
+      {
+         // Create dataspace with initial size and unlimited max size
+         hsize_t dims[1] = {static_cast<hsize_t>(variableLocation_.getNumElements())};
+         hsize_t maxDims[1] = {H5S_UNLIMITED};
+         DataSpace dataspace(1, dims, maxDims);
+
+         // Create dataset
+         hdf5DataSet_ = resultOut_->createDataSet(variableName_, hdf5Datatype_, dataspace);
+
+         std::cout << "Created dataset: " << variableName_ << std::endl;
+      }
+   };
+
    ///@{
    /** These methods are intended only for unit tests */
    /// constructor only for unit test
@@ -103,6 +163,12 @@ class Hdf5Recorder : public Recorder {
       resultFileName_ = fileName;
    }
 
+   // Accessor method to retrieve variableTable_
+   const vector<singleVariableInfo> &getVariableTable() const
+   {
+      return variableTable_;
+   }
+
 private:
    virtual void initDataSet();
 
@@ -147,6 +213,8 @@ class Hdf5Recorder : public Recorder {
    // track spikes count of probed neurons
    vector<vector<uint64_t>> spikesProbedNeurons_;
 
+   /// List of registered variables for recording
+   vector<singleVariableInfo> variableTable_;
    // Other member functions...
 };
 

Testing/UnitTesting/Hdf5RecorderTests.cpp

@@ -1,8 +1,38 @@
+#include "EventBuffer.h"
 #include "Hdf5Recorder.h"
+#include "RecordableBase.h"
+#include "RecordableVector.h"
 #include "Recorder.h"
 #include "gtest/gtest.h"
 
 #if defined(HDF5)
+   #include "H5Cpp.h"
+
+// Unit test for verifying the registerVariable method
+TEST(Hdf5RecorderTest, RegisterVariableTest)
+{
+   // Create an instance of Hdf5Recorder
+   std::string outputFile = "../Testing/UnitTesting/TestOutput/Hdf5test_output_register.h5";
+   Hdf5Recorder recorder(outputFile);
+   recorder.init();
+
+   // Create an EventBuffer for testing
+   EventBuffer eventBuffer;
+   const H5std_string hdf5Name("test_var");
+
+   // Register the variable
+   recorder.registerVariable(hdf5Name, eventBuffer, Recorder::UpdatedType::CONSTANT);
+
+   // Retrieve the registered variable info
+   const Hdf5Recorder::singleVariableInfo &varInfo = recorder.getVariableTable()[0];
+
+   // Verify the variable type
+   ASSERT_EQ(Recorder::UpdatedType::CONSTANT, varInfo.variableType_);
+   // Verify the variable name
+   ASSERT_EQ(hdf5Name, varInfo.variableName_);
+   // Verify the HDF5 data type
+   ASSERT_EQ(PredType::NATIVE_UINT64, varInfo.hdf5Datatype_);
+}
 
 // Test case for initializing the Hdf5Recorder
 TEST(Hdf5RecorderTest, CreateInstanceSuccess)