Add pflow unit tests (#197)

hambrickjc · pelesh · web-flow · commit 43ae6f472c16 · 2026-02-27T13:46:25.000-05:00
---------

Co-authored-by: Slaven Peles &lt;peless@ornl.gov&gt;
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -16,8 +16,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### PS
 
+- Added improved parser for RAW file format.
+- Added support for PSS/E contingecy file format
+
 ### PFLOW
 
+- Added unit tests for PFLOW
+
 ### OPFLOW
 
 ### TCOPFLOW
diff --git a/datafiles/test_validation/case118.m/Jacpf_valid.bin b/datafiles/test_validation/case118.m/Jacpf_valid.bin
diff --git a/datafiles/test_validation/case118.m/Jacpf_valid.bin.info b/datafiles/test_validation/case118.m/Jacpf_valid.bin.info
@@ -0,0 +1 @@
+-matload_block_size 2
diff --git a/datafiles/test_validation/case9mod.m/Jacpf_valid.bin b/datafiles/test_validation/case9mod.m/Jacpf_valid.bin
diff --git a/datafiles/test_validation/case9mod.m/Jacpf_valid.bin.info b/datafiles/test_validation/case9mod.m/Jacpf_valid.bin.info
@@ -0,0 +1 @@
+-matload_block_size 2
diff --git a/datafiles/test_validation/case_ACTIVSg200.m/Jacpf_valid.bin b/datafiles/test_validation/case_ACTIVSg200.m/Jacpf_valid.bin
diff --git a/datafiles/test_validation/case_ACTIVSg200.m/Jacpf_valid.bin.info b/datafiles/test_validation/case_ACTIVSg200.m/Jacpf_valid.bin.info
@@ -0,0 +1 @@
+-matload_block_size 2
diff --git a/include/pflow.h b/include/pflow.h
@@ -46,5 +46,6 @@ PETSC_EXTERN PetscErrorCode PFLOWPrintSolution(PFLOW);
 PETSC_EXTERN PetscErrorCode PFLOWSetGICData(PFLOW, const char[]);
 PETSC_EXTERN PetscErrorCode PFLOWSaveSolutionDefault(PFLOW, const char[]);
 PETSC_EXTERN PetscErrorCode PFLOWSetOutputFormat(PFLOW, OutputFormat);
+PETSC_EXTERN PetscErrorCode PFLOWGetJacobian(PFLOW, Mat *);
 
 #endif
diff --git a/src/pflow/pflow.cpp b/src/pflow/pflow.cpp
@@ -1733,3 +1733,22 @@ PetscErrorCode PFLOWSetSummaryStats(PFLOW pflow) {
 
   PetscFunctionReturn(0);
 }
+
+/*
+  PFLOWGetJacobian - Returns the Jacobian matrix
+
+  Inputs:
+. pflow - the PFLOW object
+
+  Outputs:
+  jac - the Jacobian matrix
+*/
+PetscErrorCode PFLOWGetJacobian(PFLOW pflow, Mat *jac) {
+  PetscErrorCode ierr;
+
+  PetscFunctionBegin;
+
+  *jac = pflow->Jac;
+
+  PetscFunctionReturn(0);
+}
diff --git a/tests/unit/CMakeLists.txt b/tests/unit/CMakeLists.txt
@@ -9,6 +9,10 @@ add_executable(test_acopf test_acopf.cpp utils/test_acopf_utils.cpp)
 target_link_libraries(test_acopf ExaGO::OPFLOW)
 target_include_directories(test_acopf PRIVATE ./utils)
 
+add_executable(test_pflow test_pflow.cpp utils/test_acopf_utils.cpp)
+target_link_libraries(test_pflow ExaGO::PFLOW)
+target_include_directories(test_pflow PRIVATE ./utils)
+
 add_executable(test_error_handler test_error_handler.cpp)
 target_link_libraries(test_error_handler ExaGO::UTILS)
 
@@ -37,6 +41,18 @@ if(EXAGO_INSTALL_TESTS)
     ${network_files}
   )
 
+  exago_add_test(
+    NAME
+    "UNIT_TESTS_PFLOW"
+    COMMAND
+    ${RUNCMD}
+    $<TARGET_FILE:test_pflow>
+    -validation_dir
+    ${CMAKE_SOURCE_DIR}/datafiles/test_validation
+    NETFILES
+    ${network_files}
+  )
+
   exago_add_test(
     NAME UNIT_TESTS_UTILS COMMAND $<TARGET_FILE:test_error_handler>
   )
diff --git a/tests/unit/pflow/pflow_tests.h b/tests/unit/pflow/pflow_tests.h
@@ -0,0 +1,100 @@
+
+#pragma once
+#include "petscsys.h"
+#include <cassert>
+#include <test_base.h>
+#include <type_traits>
+
+#include <common.h>
+#include <exago_config.h>
+#include <pflow.h>
+#include <private/pflowimpl.h>
+
+//#if defined(EXAGO_ENABLE_RAJA)
+//#include <RAJA/RAJA.hpp>
+//#include <umpire/Allocator.hpp>
+//#include <umpire/ResourceManager.hpp>
+//#endif
+
+//#define cleanup(fail, opflow)                                                  \
+//  printMessage(fail, __func__, getRank(opflow));                               \
+//  return reduceReturn(fail, opflow);
+
+namespace exago {
+namespace tests {
+
+class TestPflow : public TestBase {
+public:
+  TestPflow() = default;
+
+  LocalOrdinalType computeJacobian(PFLOW pflow, Mat JRef) {
+
+    PetscErrorCode ierr;
+    LocalOrdinalType fail = 0;
+    Mat J;
+
+    ierr = PFLOWCreateMatrix(pflow, &J);
+    CHKERRQ(ierr);
+
+    ierr = PFLOWGetJacobian(pflow, &J);
+    CHKERRQ(ierr);
+
+    fail += verifyAnswer(J, JRef);
+
+    return (fail);
+  }
+
+  virtual int verifyAnswer(Mat a, Mat b, const RealType &tol = eps) const {
+    int ncols, ncolsref;
+    int fail = 0;
+    const int *cols, *colsref;
+    const double *vals, *valsref;
+    PetscInt nrow, ncol, nrowref, ncolref;
+    PetscErrorCode ierr;
+    auto idx = [&ncol](double *mat, int r, int c) {
+      return mat[(r * ncol) + c];
+    };
+
+    // MatView(a, 0);
+    // MatView(b, 0);
+
+    ierr = MatGetSize(a, &nrow, &ncol);
+    CHKERRQ(ierr);
+    ierr = MatGetSize(b, &nrowref, &ncolref);
+    CHKERRQ(ierr);
+
+    if (nrow != nrowref) {
+      std::cout << "Failed due to row count: J: " << nrow
+                << " JRef: " << nrowref << std::endl;
+      fail++;
+    }
+    if (ncol != ncolref) {
+      std::cout << "Failed due to column count: J: " << ncol
+                << " JRef: " << ncolref << std::endl;
+      fail++;
+    }
+
+    if (fail == 0) {
+      for (int i = 0; i < nrow; i++) {
+        ierr = MatGetRow(a, i, &ncols, &cols, &vals);
+        CHKERRQ(ierr);
+        ierr = MatGetRow(b, i, &ncolsref, &colsref, &valsref);
+        for (int j = 0; j < ncols; j++) {
+          // std::cout << "J: " << vals[j] << " JRef: " << valsref[j] <<
+          // std::endl;
+          if (!isEqual(vals[j], valsref[j], tol)) {
+            std::cout << "Failed for index (" << i << ", " << cols[j]
+                      << ") : " << vals[j] << " != " << valsref[j] << std::endl;
+            fail++;
+          }
+        }
+      }
+    }
+
+    return fail;
+  }
+
+}; // class TestOpflow : public TestBase
+
+} // namespace tests
+} // namespace exago
diff --git a/tests/unit/test_pflow.cpp b/tests/unit/test_pflow.cpp
@@ -0,0 +1,197 @@
+#include <cstdio>
+#include <iostream>
+#include <string>
+
+#include <exago_config.h>
+#include <private/pflowimpl.h>
+#include <utils.h>
+
+#include <pflow.h>
+#include "pflow/pflow_tests.h"
+#include "test_acopf_utils.h"
+
+//#if defined(EXAGO_ENABLE_RAJA)
+//#include <RAJA/RAJA.hpp>
+//#include <private/raja_exec_config.h>
+//#include <umpire/Allocator.hpp>
+//#include <umpire/ResourceManager.hpp>
+//#endif
+
+/**
+ * TODO: Update this section
+ * @brief Unit test driver for ACOPF models
+ * @see opflow/opflow_tests.h for kernels tested by this driver
+ *
+ * You can pass several options to the TestAcopf executatable through the
+ * command line (implemented using PETSc options):
+ *
+ *    ~ -netfile <data_file> : Specifies the input data file to test against.
+ * Default value is `/<exago_dir>/datafiles/case9/case9mod.m`. See directory
+ * datafiles for other potential inputs.
+ *
+ *    ~ -gen_test_data       : If used, generates an answer key using IPOPT to
+ * test against. If not used, uses existing answer keys located in
+ * `/<exago_dir>/datafiles/test_validation`.
+ *
+ *    ~ -write_test_data     : If used, generates test data, and then writes out
+ * the results to `/<install_dir>/tests/datafiles/test_validation/<data_file>/`.
+ *                             In order to save generated results, you should
+ * copy them into `/<exago_dir>/datafiles/test_validation/<data_file>/` and add
+ * them to git.
+ *
+ */
+int main(int argc, char **argv) {
+  //  const bool isTestPflowModelPBPOL = false;
+  //#if defined(EXAGO_ENABLE_RAJA)
+  //  const bool isTestPflowModelPBPOLRAJAHIOP = true;
+  //  const bool isTestPflowModelPBPOLHIOP = false;
+  //#else
+  //  const bool isTestPflowModelPBPOLHIOP = true;
+  //#endif
+  PetscErrorCode ierr;
+  PetscBool flg, gen_test_data, write_test_data;
+  PetscInt iter;
+  PetscBool converged = PETSC_FALSE;
+  // Vec X, Xl, Xu, G, Gl, Gu, grad, Lambda;
+  Mat Jac;
+  int fail = 0;
+  PetscLogStage stages[2];
+  double obj_value, obj_factor;
+  char file_c_str[PETSC_MAX_PATH_LEN];
+  char validation_dir_c_str[PETSC_MAX_PATH_LEN];
+  std::string file, validation_path;
+  char appname[] = "pflow";
+  MPI_Comm comm = MPI_COMM_WORLD;
+
+  char help[] = "Unit tests for PFLOW\n";
+
+  /** Use `ExaGOLogSetLoggingFileName("opflow-logfile");` to log the output. */
+  ierr = ExaGOInitialize(comm, &argc, &argv, appname, help);
+  if (ierr) {
+    fprintf(stderr, "Could not initialize ExaGO application %s.\n", appname);
+    return ierr;
+  }
+
+  /* Get network data file from command line */
+  ierr = PetscOptionsGetString(NULL, NULL, "-netfile", file_c_str,
+                               PETSC_MAX_PATH_LEN, &flg);
+  CHKERRQ(ierr);
+
+  if (!flg) {
+    file = "../datafiles/case9/case9mod.m";
+  } else {
+    file.assign(file_c_str);
+  }
+
+  std::cout << file << std::endl;
+
+  /* Place to store/read reference solutions */
+  ierr = PetscOptionsGetString(NULL, NULL, "-validation_dir",
+                               validation_dir_c_str, PETSC_MAX_PATH_LEN, &flg);
+  CHKERRQ(ierr);
+
+  /* This defaults to within the install directory */
+  if (!flg) {
+    validation_path = std::string(EXAGO_OPTIONS_DIR) +
+                      std::string("../datafiles/test_validation/") +
+                      getFileName(file) + "/";
+  } else {
+    validation_path =
+        std::string(validation_dir_c_str) + "/" + getFileName(file) + "/";
+  }
+
+  ierr =
+      PetscOptionsGetBool(NULL, NULL, "-gen_test_data", NULL, &gen_test_data);
+  CHKERRQ(ierr);
+  ierr = PetscOptionsGetBool(NULL, NULL, "-write_test_data", NULL,
+                             &write_test_data);
+  CHKERRQ(ierr);
+
+  ierr = PetscLogStageRegister("Solution key", &stages[0]);
+  CHKERRQ(ierr);
+  ierr = PetscLogStageRegister("Test stage", &stages[1]);
+  CHKERRQ(ierr);
+
+  ierr = PetscLogStagePush(stages[0]);
+
+  if (gen_test_data || write_test_data) {
+    std::cout << "Generating test_validation data from existing model."
+              << std::endl;
+
+    PFLOW pflow;
+
+    /* Create reference pflow */
+    ierr = PFLOWCreate(PETSC_COMM_WORLD, &pflow);
+    CHKERRQ(ierr);
+
+    /* Read Network data */
+    ierr = PFLOWReadMatPowerData(pflow, file.c_str());
+    CHKERRQ(ierr);
+
+    /* Solve PFLOW to get the reference solution */
+    ierr = PFLOWSolve(pflow);
+
+    /* Get the reference solution */
+    ierr = PFLOWConverged(pflow, &converged);
+    CHKERRQ(ierr);
+
+    ierr = PFLOWGetNumIterations(pflow, &iter);
+    CHKERRQ(ierr);
+
+    ierr = PFLOWCreateMatrix(pflow, &Jac);
+    CHKERRQ(ierr);
+
+    ierr = PFLOWGetJacobian(pflow, &Jac);
+    CHKERRQ(ierr);
+
+    if (write_test_data) {
+      std::cout << "Writing answer keys to " << validation_path << std::endl;
+
+      validate_directory(validation_path);
+      saveToFile(Jac, validation_path + "Jacpf_valid.bin");
+    }
+  } else {
+    std::cout << "Loading answer key from " << validation_path << std::endl;
+    readFromFile(&Jac, validation_path + "Jacpf_valid.bin");
+  }
+
+  ierr = PetscLogStagePop();
+  CHKERRQ(ierr);
+
+  ierr = PetscLogStagePush(stages[1]);
+  CHKERRQ(ierr);
+
+  exago::tests::TestPflow test;
+  PFLOW pflowtest;
+
+  ierr = PFLOWCreate(PETSC_COMM_WORLD, &pflowtest);
+  CHKERRQ(ierr);
+
+  ierr = PFLOWReadMatPowerData(pflowtest, file.c_str());
+  CHKERRQ(ierr);
+
+  ierr = PFLOWSetUp(pflowtest);
+  CHKERRQ(ierr);
+
+  ierr = PFLOWSolve(pflowtest);
+  CHKERRQ(ierr);
+
+  ierr = PFLOWGetConvergenceStatus(pflowtest, &converged);
+  CHKERRQ(ierr);
+
+  std::cout << "Convergence status: " << (bool)converged << std::endl;
+
+  std::cout << "testing Jacobian" << std::endl;
+  fail += test.computeJacobian(pflowtest, Jac);
+
+  // ierr = PFLOWDestroy(&pflowtest);
+  // CHKERRQ(ierr);
+
+  /* Destroy PFLOW objects */
+  ierr = MatDestroy(&Jac);
+  CHKERRQ(ierr);
+
+  ExaGOFinalize();
+  // PetscFinalize();
+  return fail;
+}
