adding some UQ tests (#1272)

* adding some UQ tests
* remove test_data_processor.py
* rolling back some changes
* fixing typos
* issues with tests in Windows
* remove mark.skip for test_genheatmap
* update to macos-14 since macos-13 is being deprecated.
actions/runner-images#13046
* add UQ RS Analysis tests
* unpinning pytest version and adding exc_type argument to pytest.importorskip
* pinning pytest again
* removing exc_type argument (not valid in this version of pytest)
* removing exc_type argument (not valid in this version of pytest)
---------
Co-authored-by: Keith Beattie <ksbeattie@lbl.gov>

Author: sotorrio1

foqus_lib/framework/graph/graph.py

@@ -1574,13 +1574,13 @@ def adjLists(self):
     def getEdgeIndex(self, vkey, wkey):
         # get index of edge from v to w returns None if no edge from v to w
         # multiple edges are not allowed
-        indx = None
+        index = None
         for i in range(0, len(self.edges)):
             if self.edges[i].start == vkey:
                 if self.edges[i].end == wkey:
-                    indx = i
+                    index = i
                     break
-        return indx
+        return index
 
     def setTearSet(self, tSet):
         # mark the given list of edges as tear edges

foqus_lib/framework/optimizer/SM_Optimizer.py

@@ -936,10 +936,10 @@ def optimize(self):
                         ]
                         nodevar = str(nodeName) + "_" + str(outVarName)
                         if nodevar in [str(v) for v in self.surrout_names_pyomo]:
-                            indx = [str(v) for v in self.surrout_names_pyomo].index(
+                            index = [str(v) for v in self.surrout_names_pyomo].index(
                                 nodevar
                             )
-                            surrin_outputvals[indx] = surrout_value
+                            surrin_outputvals[index] = surrout_value
 
                 surrin_samples_values.append(surrin_outputvals)
             latin_hypercube_samples_values = np.array(surrin_samples_values)

foqus_lib/framework/uq/SampleData.py

@@ -196,7 +196,12 @@ def saveDict(self):
             sd["outputData"] = self.outputData.tolist()
         else:
             sd["outputData"] = self.outputData
-        sd["runState"] = self.runState.tolist()
+
+        if isinstance(self.runState, numpy.ndarray):
+            sd["runState"] = self.runState.tolist()
+        else:
+            sd["runState"] = self.runState
+
         sd["legendreOrder"] = self.legendreOrder
         sd["fromFile"] = self.fromFile
         sd["sampleRSType"] = ResponseSurfaces.getPsuadeName(self.sampleRSType)

foqus_lib/framework/uq/test/__init__.py

@@ -0,0 +1,136 @@
+#################################################################################
+# FOQUS Copyright (c) 2012 - 2025, by the software owners: Oak Ridge Institute
+# for Science and Education (ORISE), TRIAD National Security, LLC., Lawrence
+# Livermore National Security, LLC., The Regents of the University of
+# California, through Lawrence Berkeley National Laboratory, Battelle Memorial
+# Institute, Pacific Northwest Division through Pacific Northwest National
+# Laboratory, Carnegie Mellon University, West Virginia University, Boston
+# University, the Trustees of Princeton University, The University of Texas at
+# Austin, URS Energy & Construction, Inc., et al.  All rights reserved.
+#
+# Please see the file LICENSE.md for full copyright and license information,
+# respectively. This file is also available online at the URL
+# "https://github.com/CCSI-Toolset/FOQUS".
+#################################################################################
+import os
+import tempfile
+import unittest
+from unittest.mock import Mock, patch
+
+from foqus_lib.framework.uq.Common import Common
+
+
+class TestCommon(unittest.TestCase):
+    """Test cases for the Common class"""
+
+    def test_get_file_name_root(self):
+        """Test extracting filename root"""
+        self.assertEqual(Common.getFileNameRoot("test.dat"), "test")
+        self.assertEqual(Common.getFileNameRoot("/path/to/file.psuade"), "file")
+        self.assertEqual(Common.getFileNameRoot("complex.file.name.txt"), "complex")
+
+    def test_get_local_filename(self):
+        """Test generating local filename"""
+        result = Common.getLocalFileName("/tmp", "test.dat", "_processed")
+        expected = "/tmp" + os.path.sep + "test_processed"
+        self.assertEqual(result, expected)
+
+    @patch("os.path.exists")
+    @patch("os.mkdir")
+    @patch("os.listdir")
+    @patch("os.unlink")
+    def test_init_folder(self, mock_unlink, mock_listdir, mock_mkdir, mock_exists):
+        """Test folder initialization"""
+        # Test creating new folder
+        mock_exists.return_value = False
+        Common.initFolder("/test/path")
+        mock_mkdir.assert_called_once_with("/test/path")
+
+        # Test cleaning existing folder
+        mock_exists.return_value = True
+        mock_listdir.return_value = ["file1.txt", "file2.dat"]
+        with patch("os.path.isfile", return_value=True):
+            Common.initFolder("/test/path", deleteFiles=True)
+            self.assertEqual(mock_unlink.call_count, 2)
+
+    @patch("foqus_lib.framework.uq.Common.usePyside", False)
+    @patch("builtins.print")
+    def test_show_error_no_pyside(self, mock_print):
+        """Test error display without PyQt"""
+        Common.showError("Test error message")
+        mock_print.assert_called_once_with("Test error message")
+
+    def test_get_user_regression_output_name(self):
+        """Test getting user regression output name"""
+        # Create a mock data object
+        mock_data = Mock()
+
+        # Test case 1: When labels contain the modified name (with underscore)
+        with tempfile.NamedTemporaryFile(mode="w", delete=False) as f:
+            f.write("# Test regression file\n")
+            f.write("labels = ['node_output1', 'node_output2']\n")
+            temp_file1 = f.name
+
+        try:
+            mock_data.getNamesIncludeNodes.return_value = False
+            result = Common.getUserRegressionOutputName(
+                "node.output1", temp_file1, mock_data
+            )
+            self.assertEqual(result, "node_output1")  # Should return the modified name
+
+            # Even when getNamesIncludeNodes is True, if the modified name is found in labels,
+            # it should still return the modified name
+            mock_data.getNamesIncludeNodes.return_value = True
+            result = Common.getUserRegressionOutputName(
+                "node.output1", temp_file1, mock_data
+            )
+            self.assertEqual(
+                result, "node_output1"
+            )  # Should still return modified name because it's in labels
+        finally:
+            os.unlink(temp_file1)
+
+        # Test case 2: When data has names that include nodes but labels don't match
+        with tempfile.NamedTemporaryFile(mode="w", delete=False) as f:
+            f.write("# Test regression file\n")
+            f.write(
+                "labels = ['other_output1', 'other_output2']\n"
+            )  # Different labels that don't match
+            temp_file2 = f.name
+
+        try:
+            mock_data.getNamesIncludeNodes.return_value = True
+            result = Common.getUserRegressionOutputName(
+                "node.output1", temp_file2, mock_data
+            )
+            self.assertEqual(result, "output1")  # Should strip the node part
+
+            # Test case 3: When data doesn't include nodes and no match in labels
+            mock_data.getNamesIncludeNodes.return_value = False
+            result = Common.getUserRegressionOutputName(
+                "node.output1", temp_file2, mock_data
+            )
+            self.assertEqual(result, "node.output1")  # Should return original name
+        finally:
+            os.unlink(temp_file2)
+
+    def test_get_user_regression_output_name_no_labels(self):
+        """Test getting user regression output name when no labels line exists"""
+        mock_data = Mock()
+        mock_data.getNamesIncludeNodes.return_value = True
+
+        # Create a temporary regression file without labels
+        with tempfile.NamedTemporaryFile(mode="w", delete=False) as f:
+            f.write("# Test regression file\n")
+            f.write("# No labels line here\n")
+            temp_file = f.name
+
+        try:
+            result = Common.getUserRegressionOutputName(
+                "node.output1", temp_file, mock_data
+            )
+            self.assertEqual(
+                result, "output1"
+            )  # Should strip node part when names include nodes
+        finally:
+            os.unlink(temp_file)

foqus_lib/framework/uq/test/test_common.py

@@ -0,0 +1,81 @@
+#################################################################################
+# FOQUS Copyright (c) 2012 - 2025, by the software owners: Oak Ridge Institute
+# for Science and Education (ORISE), TRIAD National Security, LLC., Lawrence
+# Livermore National Security, LLC., The Regents of the University of
+# California, through Lawrence Berkeley National Laboratory, Battelle Memorial
+# Institute, Pacific Northwest Division through Pacific Northwest National
+# Laboratory, Carnegie Mellon University, West Virginia University, Boston
+# University, the Trustees of Princeton University, The University of Texas at
+# Austin, URS Energy & Construction, Inc., et al.  All rights reserved.
+#
+# Please see the file LICENSE.md for full copyright and license information,
+# respectively. This file is also available online at the URL
+# "https://github.com/CCSI-Toolset/FOQUS".
+#################################################################################
+import unittest
+from unittest.mock import Mock, patch
+
+
+class TestCorrelationAnalysis(unittest.TestCase):
+    """Test cases for CorrelationAnalysis"""
+
+    def setUp(self):
+        """Set up test correlation analysis"""
+        from foqus_lib.framework.uq.CorrelationAnalysis import CorrelationAnalysis
+
+        # Mock ensemble and output
+        self.mock_ensemble = Mock()
+        self.mock_output = "test_output"
+
+        self.ca = CorrelationAnalysis(self.mock_ensemble, self.mock_output)
+
+    def test_initialization(self):
+        """Test CorrelationAnalysis initialization"""
+        # Test that the object was created successfully
+        self.assertIsNotNone(self.ca)
+
+        # Test that ensemble and outputs are set correctly
+        self.assertEqual(self.ca.ensemble, self.mock_ensemble)
+        self.assertEqual(self.ca.outputs, ["test_output"])
+
+        # Test that moments is initialized to None
+        self.assertIsNone(self.ca.moments)
+
+        # If there's a way to check the analysis type, we can test it
+        # For now, we'll just verify the object is properly instantiated
+
+    @patch("foqus_lib.framework.uq.CorrelationAnalysis.RawDataAnalyzer.performCA")
+    @patch("foqus_lib.framework.uq.CorrelationAnalysis.Common.initFolder")
+    def test_analyze(self, mock_init_folder, mock_perform_ca):
+        """Test correlation analysis"""
+        # Mock valid samples
+        mock_data = Mock()
+        mock_data.getModelName.return_value = "test_model"
+        mock_data.writeToPsuade = Mock()
+        self.mock_ensemble.getValidSamples.return_value = mock_data
+
+        mock_perform_ca.return_value = "results.m"
+
+        result = self.ca.analyze()
+
+        mock_init_folder.assert_called_once()
+        mock_perform_ca.assert_called_once()
+        self.assertEqual(result, "results.m")
+
+    @patch("foqus_lib.framework.uq.CorrelationAnalysis.RawDataAnalyzer.plotCA")
+    def test_show_results(self, mock_plot_ca):
+        """Test showing correlation analysis results"""
+        # Mock the archiveFile and restoreFromArchive methods
+        self.ca.archiveFile = Mock()
+        self.ca.restoreFromArchive = Mock()
+
+        # Call showResults
+        self.ca.showResults()
+
+        # Verify that restoreFromArchive was called with the correct filename
+        self.ca.restoreFromArchive.assert_called_once_with("matlabca.m")
+
+        # Verify that plotCA was called with correct parameters
+        mock_plot_ca.assert_called_once_with(
+            self.mock_ensemble, "test_output", "matlabca.m"
+        )

foqus_lib/framework/uq/test/test_correlation_analysis.py

@@ -0,0 +1,119 @@
+#################################################################################
+# FOQUS Copyright (c) 2012 - 2025, by the software owners: Oak Ridge Institute
+# for Science and Education (ORISE), TRIAD National Security, LLC., Lawrence
+# Livermore National Security, LLC., The Regents of the University of
+# California, through Lawrence Berkeley National Laboratory, Battelle Memorial
+# Institute, Pacific Northwest Division through Pacific Northwest National
+# Laboratory, Carnegie Mellon University, West Virginia University, Boston
+# University, the Trustees of Princeton University, The University of Texas at
+# Austin, URS Energy & Construction, Inc., et al.  All rights reserved.
+#
+# Please see the file LICENSE.md for full copyright and license information,
+# respectively. This file is also available online at the URL
+# "https://github.com/CCSI-Toolset/FOQUS".
+#################################################################################
+import unittest
+
+from foqus_lib.framework.uq.Distribution import Distribution
+
+
+class TestDistribution(unittest.TestCase):
+    """Test cases for the Distribution class"""
+
+    def test_static_methods(self):
+        """Test all static methods"""
+        # Test getFullName
+        self.assertEqual(Distribution.getFullName(Distribution.UNIFORM), "Uniform")
+        self.assertEqual(Distribution.getFullName(Distribution.NORMAL), "Normal")
+        self.assertEqual(Distribution.getFullName(Distribution.LOGNORMAL), "Lognormal")
+
+        # Test getPsuadeName
+        self.assertEqual(Distribution.getPsuadeName(Distribution.UNIFORM), "U")
+        self.assertEqual(Distribution.getPsuadeName(Distribution.NORMAL), "N")
+        self.assertEqual(Distribution.getPsuadeName(Distribution.BETA), "B")
+
+        # Test getInfo
+        info = Distribution.getInfo(Distribution.GAMMA)
+        self.assertEqual(info, ("Gamma", "G"))
+
+        # Test getEnumValue
+        self.assertEqual(Distribution.getEnumValue("Uniform"), Distribution.UNIFORM)
+        self.assertEqual(Distribution.getEnumValue("N"), Distribution.NORMAL)
+        self.assertEqual(Distribution.getEnumValue("T"), Distribution.TRIANGLE)
+
+        # Test getParameterNames
+        params = Distribution.getParameterNames(Distribution.NORMAL)
+        self.assertEqual(params, ("Mean", "Std Dev"))
+
+        params = Distribution.getParameterNames(Distribution.UNIFORM)
+        self.assertEqual(params, (None, None))
+
+        params = Distribution.getParameterNames(Distribution.EXPONENTIAL)
+        self.assertEqual(params, ("Lambda", None))
+
+    def test_distribution_creation_with_enum(self):
+        """Test creating distribution with enum values"""
+        dist = Distribution(Distribution.NORMAL)
+        self.assertEqual(dist.getDistributionType(), Distribution.NORMAL)
+
+    def test_distribution_creation_with_string(self):
+        """Test creating distribution with string values"""
+        dist = Distribution("Normal")
+        self.assertEqual(dist.getDistributionType(), Distribution.NORMAL)
+
+        dist = Distribution("L")  # Lognormal
+        self.assertEqual(dist.getDistributionType(), Distribution.LOGNORMAL)
+
+    def test_parameter_values(self):
+        """Test setting and getting parameter values"""
+        dist = Distribution(Distribution.NORMAL)
+
+        # Initially None
+        self.assertEqual(dist.getParameterValues(), (None, None))
+
+        # Set both parameters
+        dist.setParameterValues(10.0, 2.5)
+        self.assertEqual(dist.getParameterValues(), (10.0, 2.5))
+
+        # Set only first parameter
+        dist.setParameterValues(15.0)
+        self.assertEqual(dist.getParameterValues(), (15.0, None))
+
+    def test_repr(self):
+        """Test string representation"""
+        dist = Distribution(Distribution.NORMAL)
+        self.assertIn("N Distribution", repr(dist))
+
+        dist.setParameterValues(10.0, 2.0)
+        repr_str = repr(dist)
+        self.assertIn("N Distribution", repr_str)
+        self.assertIn("10.0", repr_str)
+        self.assertIn("2.0", repr_str)
+
+    def test_save_load_dict(self):
+        """Test saving and loading distribution to/from dictionary"""
+        dist = Distribution(Distribution.GAMMA)
+        dist.setParameterValues(2.0, 1.5)
+
+        # Save to dict
+        saved = dist.saveDict()
+        self.assertEqual(saved["type"], "G")
+        self.assertEqual(saved["firstParamValue"], 2.0)
+        self.assertEqual(saved["secondParamValue"], 1.5)
+
+        # Load from dict
+        new_dist = Distribution(Distribution.UNIFORM)  # Start with different type
+        new_dist.loadDict(saved)
+        self.assertEqual(new_dist.getDistributionType(), Distribution.GAMMA)
+        self.assertEqual(new_dist.getParameterValues(), (2.0, 1.5))
+
+    def test_distribution_type_changes(self):
+        """Test changing distribution type"""
+        dist = Distribution(Distribution.UNIFORM)
+        self.assertEqual(dist.getDistributionType(), Distribution.UNIFORM)
+
+        dist.setDistributionType(Distribution.WEIBULL)
+        self.assertEqual(dist.getDistributionType(), Distribution.WEIBULL)
+
+        dist.setDistributionType("Beta")
+        self.assertEqual(dist.getDistributionType(), Distribution.BETA)