UQPyL 2.1.3__tar.gz → 2.1.5__tar.gz

{UQPyL-2.1.3 → uqpyl-2.1.5}/PKG-INFO

@@ -1,30 +1,44 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: UQPyL
-Version: 2.1.3
+Version: 2.1.5
 Summary: A python package for parameter uncertainty quantification and optimization
 Author: wmtSky
 Author-email: wmtSky <wmtsky@hhu.edu.cn>
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
+Requires-Dist: numpy<2
+Requires-Dist: scipy
+Requires-Dist: prettytable
+Requires-Dist: xarray
+Requires-Dist: netcdf4<1.7; python_version < "3.9"
+Requires-Dist: netcdf4; python_version >= "3.9"
+Dynamic: author
 
 # UQPyL:  Uncertainty Quantification Python Lab
 
 <p align="center"><img src="./docs/UQ.svg" width="400"/></p>
 
-[![PyPI version](https://badge.fury.io/py/UQPyL.svg?icon=si%3Apython&icon_color=%2331aadd)](https://badge.fury.io/py/UQPyL) ![PyPI - Downloads](https://img.shields.io/pypi/dm/UQPyL) ![PyPI - License](https://img.shields.io/pypi/l/UQPyL) ![GitHub last commit](https://img.shields.io/github/last-commit/smasky/UQPyL) ![Static Badge](https://img.shields.io/badge/Author-wmtSky-orange) ![Static Badge](https://img.shields.io/badge/Contact-wmtsmasky%40gmail.com-blue)
+[![PyPI version](https://badge.fury.io/py/UQPyL.svg?icon=si%3Apython&icon_color=%2331aadd)](https://badge.fury.io/py/UQPyL) [![CI](https://github.com/smasky/UQPyL/actions/workflows/ci.yml/badge.svg)](https://github.com/smasky/UQPyL/actions/workflows/ci.yml) [![codecov](https://codecov.io/gh/smasky/UQPyL/branch/dev/graph/badge.svg)](https://codecov.io/gh/smasky/UQPyL) ![PyPI - Downloads](https://img.shields.io/pypi/dm/UQPyL) ![PyPI - License](https://img.shields.io/pypi/l/UQPyL) ![GitHub last commit](https://img.shields.io/github/last-commit/smasky/UQPyL) ![Static Badge](https://img.shields.io/badge/Author-wmtSky-orange) ![Static Badge](https://img.shields.io/badge/Contact-wmtsmasky%40gmail.com-blue)
 
-**UQPyL** is a Python package for **Uncertainty Quantification** and **Optimization** of computational models and their associated problems (e.g., model calibration, resource scheduling, product design). It includes a wide range of methods and algorithms for Design of Experiments, Sensitivity Analysis, Optimization (Single- and Multi-objective). Additionally, **Surrogate Models** are built-in for solving computationally expensive problems. 
+**UQPyL** is a Python package for **Uncertainty Quantification** and **Optimization** of computational models and their associated problems (e.g., model calibration, resource scheduling, product design). It includes a wide range of methods and algorithms for Design of Experiments, Sensitivity Analysis, Bayesian Inference, Optimization (Single- and Multi-objective). Additionally, **Surrogate Models** are built-in for solving computationally expensive problems. 
 
 👉[中文简介](https://github.com/smasky/UQPyL/blob/dev/README_CN.md)
 
-👉[Documentation](https://uqpyl.readthedocs.io/en/latest/)
+👉[中文文档](https://swat-uq.readthedocs.io/en/latest/zh/index.html)
+
+👉[Documentation](https://uqpyl.readthedocs.io)
+
+## Changelog
+
+- 2025.12.14:  Added the **inference** module. And results are now saved in **NetCDF** format, replacing the previous HDF output.
+
 
 ## Contents
 

{UQPyL-2.1.3 → uqpyl-2.1.5}/README.md

@@ -2,13 +2,20 @@
 
 <p align="center"><img src="./docs/UQ.svg" width="400"/></p>
 
-[![PyPI version](https://badge.fury.io/py/UQPyL.svg?icon=si%3Apython&icon_color=%2331aadd)](https://badge.fury.io/py/UQPyL) ![PyPI - Downloads](https://img.shields.io/pypi/dm/UQPyL) ![PyPI - License](https://img.shields.io/pypi/l/UQPyL) ![GitHub last commit](https://img.shields.io/github/last-commit/smasky/UQPyL) ![Static Badge](https://img.shields.io/badge/Author-wmtSky-orange) ![Static Badge](https://img.shields.io/badge/Contact-wmtsmasky%40gmail.com-blue)
+[![PyPI version](https://badge.fury.io/py/UQPyL.svg?icon=si%3Apython&icon_color=%2331aadd)](https://badge.fury.io/py/UQPyL) [![CI](https://github.com/smasky/UQPyL/actions/workflows/ci.yml/badge.svg)](https://github.com/smasky/UQPyL/actions/workflows/ci.yml) [![codecov](https://codecov.io/gh/smasky/UQPyL/branch/dev/graph/badge.svg)](https://codecov.io/gh/smasky/UQPyL) ![PyPI - Downloads](https://img.shields.io/pypi/dm/UQPyL) ![PyPI - License](https://img.shields.io/pypi/l/UQPyL) ![GitHub last commit](https://img.shields.io/github/last-commit/smasky/UQPyL) ![Static Badge](https://img.shields.io/badge/Author-wmtSky-orange) ![Static Badge](https://img.shields.io/badge/Contact-wmtsmasky%40gmail.com-blue)
 
-**UQPyL** is a Python package for **Uncertainty Quantification** and **Optimization** of computational models and their associated problems (e.g., model calibration, resource scheduling, product design). It includes a wide range of methods and algorithms for Design of Experiments, Sensitivity Analysis, Optimization (Single- and Multi-objective). Additionally, **Surrogate Models** are built-in for solving computationally expensive problems. 
+**UQPyL** is a Python package for **Uncertainty Quantification** and **Optimization** of computational models and their associated problems (e.g., model calibration, resource scheduling, product design). It includes a wide range of methods and algorithms for Design of Experiments, Sensitivity Analysis, Bayesian Inference, Optimization (Single- and Multi-objective). Additionally, **Surrogate Models** are built-in for solving computationally expensive problems. 
 
 👉[中文简介](https://github.com/smasky/UQPyL/blob/dev/README_CN.md)
 
-👉[Documentation](https://uqpyl.readthedocs.io/en/latest/)
+👉[中文文档](https://swat-uq.readthedocs.io/en/latest/zh/index.html)
+
+👉[Documentation](https://uqpyl.readthedocs.io)
+
+## Changelog
+
+- 2025.12.14:  Added the **inference** module. And results are now saved in **NetCDF** format, replacing the previous HDF output.
+
 
 ## Contents
 

uqpyl-2.1.5/UQPyL/__init__.py

@@ -0,0 +1,46 @@
+"""
+UQPyL package entry.
+
+CI (Linux) is case-sensitive. If the repository historically contains a mixed-case
+DOE folder name (e.g. `DoE`), imports like `import UQPyL.doe` or relative imports
+`from ..doe import ...` will fail. To make the package robust across platforms,
+we create a small alias between `UQPyL.doe` and `UQPyL.DoE` before importing other
+subpackages (some of which depend on DOE at import-time).
+"""
+
+import importlib
+import sys
+
+# --- DOE/DoE compatibility shim (must run early) ---
+_doe_mod = None
+try:
+    _doe_mod = importlib.import_module(__name__ + ".doe")
+except ModuleNotFoundError:
+    try:
+        _doe_mod = importlib.import_module(__name__ + ".DoE")
+    except ModuleNotFoundError:
+        _doe_mod = None
+
+if _doe_mod is not None:
+    # Alias both names to the same module object.
+    sys.modules.setdefault(__name__ + ".doe", _doe_mod)
+    sys.modules.setdefault(__name__ + ".DoE", _doe_mod)
+
+# Import subpackages after the shim so downstream imports won't crash.
+from . import problem, surrogate, optimization, analysis, util, inference  # noqa: E402,F401
+
+# Keep `doe` attribute if available
+doe = _doe_mod  # noqa: E402
+
+__version__ = "2.1.5"
+__author__ = "wmtSky"
+
+__all__=[
+    "problem",
+    "surrogate",
+    "optimization",
+    "analysis",
+    "doe",
+    "inference",
+    "util"
+]

uqpyl-2.1.5/UQPyL/analysis/__init__.py

@@ -0,0 +1,16 @@
+from .morris import Morris
+from .fast import FAST
+from .rbd_fast import RBDFAST
+from .sobol import Sobol
+from .delta import DeltaTest
+from .mars import MARS
+from .rsa import RSA
+
+__all__=["Morris",
+         "FAST",
+         "RBDFAST",
+         "Sobol",
+         "DeltaTest",
+         "MARS",
+         "RSA"
+         ]

uqpyl-2.1.5/UQPyL/analysis/base.py

@@ -0,0 +1,333 @@
+import abc
+from typing import Tuple, Optional
+import numpy as np
+import xarray as xr
+from datetime import datetime
+
+from ..util import Scaler
+from ..problem import ProblemABC as Problem
+
+class AnalysisABC(metaclass=abc.ABCMeta):
+    
+    """
+    Abstract base class for analysis methods.
+    This class provides some common interfaces for analysis methods.
+    """
+
+    def __init__(self, scalers: Tuple[Optional[Scaler], Optional[Scaler]], 
+                 verboseFlag: bool = False, logFlag: bool = False, saveFlag: bool = False):
+        
+        """
+        Initialize the analysis base class with optional scalers and flags.
+
+        :param scalers: Tuple[Optional[Scaler], Optional[Scaler]] - Tuple containing scalers for input (X) and output (Y) data.
+        :param verboseFlag: bool - If True, enables verbose mode for logging.
+        :param logFlag: bool - If True, enables logging of results.
+        :param saveFlag: bool - If True, saves the results to a file.
+        """
+        
+        # Initialize input scaler
+        if scalers[0] is None:
+            self.xScale = None
+        else:
+            if not isinstance(scalers[0], Scaler):
+                raise TypeError("scaler must be an instance of Scaler or None!")
+            self.xScale = scalers[0]
+        
+        # Initialize output scaler
+        if scalers[1] is None:
+            self.yScale = None
+        else:
+            if not isinstance(scalers[1], Scaler):
+                raise TypeError("scaler must be an instance of Scaler or None!")
+            self.yScale = scalers[1]
+
+        # Set flags for verbosity, logging, and saving
+        self.verboseFlag = verboseFlag
+        self.logFlag = logFlag
+        self.saveFlag = saveFlag
+        
+        # Initialize settings and results
+        self.setting = Setting()
+        self.result = Result(self)
+        
+    def setParaValue(self, key, value):
+        
+        """
+        Set a parameter for the sensitivity analysis.
+
+        :param key: str - The name of the parameter.
+        :param value: Any - The value of the parameter.
+        """
+        
+        self.setting.setParaValue(key, value)
+    
+    def getParaValue(self, *args):
+        
+        """
+        Retrieve the value of one or more parameters.
+
+        :param args: str - The names of the parameters to retrieve.
+        :return: The value(s) of the specified parameter(s).
+        """
+        
+        return self.setting.getParaValue(*args) 
+        
+    def setProblem(self, problem: Problem):
+        
+        """
+        Set the problem instance for the analysis.
+
+        :param problem: Problem - The problem instance defining the input and output space.
+        """
+        
+        self.problem = problem
+    
+    def check_Y(self, X, Y, target = 'objFunc', index = 'all'):
+        # Evaluate the problem if Y is not provided
+        if Y is None:
+            if target == 'objFunc':
+                Y = self.problem.objFunc(X)
+            elif target == 'conFunc':
+                Y = self.problem.conFunc(X)
+            else:
+                raise ValueError("Target must be 'objFunc' or 'conFunc'!")
+
+        if index != 'all':
+            if not isinstance(index, list):
+                raise ValueError("Index must be a list of integers!")
+            else:
+                try:
+                    Y = Y[:, index]
+                except:
+                    raise ValueError("Please check the index you set!")
+        
+        return Y
+    
+    def recordResult(self, X, Y, res):
+        
+        self.result.res['history'] = (X, Y)
+        self.result.res['results'] = res
+        
+        self.result.res['verbose'] = {}
+        
+        for (name, val, row, col, _) in res:
+            
+            for i, t in enumerate(row):
+                self.record(t, name, col, val[i])
+        
+        
+    def record(self, target, indicator, labels, values):
+
+        """
+        Record the analysis results.
+        
+        :param target: str - The target of the objective function or constraint function.
+        :param indicator: str - The indicator of the analysis.
+        :param labels: list - The labels for the input variables.
+        :param value: list - The sensitivity indices.
+        """
+                        
+        self.result.res['verbose'].setdefault(target, {})
+        self.result.res['verbose'][target].setdefault(indicator, {})
+        
+        for label, v in zip(labels, values):
+            
+            self.result.res['verbose'][target][indicator][label] = v
+        
+        self.result.res['verbose'][target][indicator]['array'] = np.array(values)
+        
+
+    def __reverse_X_Y__(self, X, Y):
+        
+        if self.xScale:
+            X = self.xScale.inverse_transform(X)
+        
+        if self.yScale:
+            Y = self.yScale.inverse_transform(Y)
+            
+        return X, Y
+    
+    
+    def __check_and_scale_xy__(self, X, Y):
+        
+        """
+        Check and scale the input and output data if scalers are provided.
+
+        :param X: np.ndarray - The input data.
+        :param Y: np.ndarray - The output data.
+        :return: Tuple[np.ndarray, np.ndarray] - The scaled input and output data.
+        """
+        
+        if not isinstance(X, np.ndarray) and X is not None:
+            raise TypeError("X must be an instance of np.ndarray or None!")
+         
+        if self.xScale:
+            X = self.xScale.fit_transform(X)
+        
+        if not isinstance(Y, np.ndarray) and Y is not None:
+            raise TypeError("Y must be an instance of np.ndarray or None!")
+
+        if Y.ndim == 1:
+            Y = Y.reshape(-1, 1)
+        
+        if self.yScale:
+            Y = self.yScale.fit_transform(Y)
+                  
+        return X, Y
+    
+    def evaluate(self, X, target = 'objFunc'):
+        
+        """
+        Evaluate the problem with the given input data.
+
+        :param X: np.ndarray - The input data.
+        :param target: str - The target to evaluate.
+        :return: np.ndarray - The output data.
+        """
+        
+        if target == 'objFunc':
+            Y = self.problem.objFunc(X)
+        elif target == 'conFunc':
+            Y = self.problem.conFunc(X)
+        else:
+            raise ValueError("Target must be 'objFunc' or 'conFunc'!")
+        
+        return Y
+    
+    @abc.abstractmethod
+    def analyze(self, X = None, Y = None):
+        
+        """
+        Abstract method for performing analysis.
+        Must be implemented by subclasses.
+        """
+        
+        pass
+
+class Result():
+    
+    """
+    Class to store and manage the results of analysis.
+    """
+
+    def __init__(self, obj):
+        """
+        Initialize the Result class.
+
+        :param obj: The analysis object.
+        """
+        
+        self.res = { }
+        
+        self.obj = obj
+    
+    def generateNetCDF(self):
+        
+        X = self.res['history'][0]; Y = self.res['history'][1]
+        res = self.res['results']
+        
+        decsDim1 = X.shape[1]
+        n = X.shape[0]
+        nI = X.shape[1]
+        nO = Y.shape[1]
+        decsDim2 = int(X.shape[1] * (X.shape[1] - 1) / 2)
+        
+        ds = xr.Dataset(
+            
+            data_vars = {
+                "X" : (("idx", "nI"), X, {"description": "decision variables"}),
+                "Y" : (("idx", "nO"), Y, {"description": "objectives or constraints"}),
+            },
+            
+            coords = {
+                'decsDim1': ("decsDim1", np.arange(decsDim1), {"description": "First-order or total-order indices of decision variables"}),
+                'decsDim2': ("decsDim2", np.arange(decsDim2), {"description": "Second-order sensitivity indices of decision variables"}),
+                'nI': ("nI", np.arange(nI), {"description": "decision variables dimensions"}),
+                'nO': ("nO", np.arange(nO), {"description": "Number of outputs"}),
+                'idx' : ("idx", np.arange(n), {"description": "Number of samples"}),
+            },
+            attrs = {
+                "problem" : f"{self.obj.problem.name}_{self.obj.problem.nInput}D_{self.obj.problem.nOutput}O_{self.obj.problem.nCons}C",
+                "method" : self.obj.name,
+                "created": datetime.now().isoformat(timespec='seconds'),
+                **{
+                    k: (str(v) if isinstance(v, bool) else v)
+                    for k, v in self.obj.setting.dict.items()
+                }
+            }
+            
+        )
+        
+        for (name, val, row, col, col_dim) in res:
+            
+            ds[name] = xr.DataArray(
+                val,
+                dims=["nO", col_dim]
+            )
+
+            if "target" not in ds.coords:
+                ds = ds.assign_coords({"target": ("nO", row, {"description": "target labels"})})
+
+            if "firstIdx" not in ds.coords and col_dim == "decsDim1":
+                ds = ds.assign_coords({"firstIdx": ("decsDim1", col, {"description": "first order indices of decision variables"})})
+                ds = ds.assign_coords({"totalIdx": ("decsDim1", col, {"description": "total order indices of decision variables"})})
+            
+            if "secondIdx" not in ds.coords and col_dim == "decsDim2":
+                ds = ds.assign_coords({"secondIdx": ("decsDim2", col, {"description": "second order indices of decision variables"})})
+                        
+        return ds
+
+class Setting():
+    """
+    Class to manage the parameter settings of the algorithm.
+    """
+
+    def __init__(self):
+        """
+        Initialize the Setting class.
+        """
+        self.dict = {}
+    
+    def keys(self):
+        """
+        Get the keys of the parameter settings.
+
+        :return: list - The keys of the parameter settings.
+        """
+        return self.dict.keys()
+    
+    def values(self):
+        """
+        Get the values of the parameter settings.
+
+        :return: list - The values of the parameter settings.
+        """
+        return self.dict.values()
+    
+    def setParaValue(self, key, value):
+        
+        """
+        Set a parameter value.
+
+        :param key: str - The name of the parameter.
+        :param value: Any - The value of the parameter.
+        """
+        
+        self.dict[key] = value
+    
+    def getParaValue(self, *args):
+        """
+        Get the value of one or more parameters.
+
+        :param args: str - The names of the parameters to retrieve.
+        :return: The value(s) of the specified parameter(s).
+        """
+        values = []
+        for arg in args:
+            values.append(self.dict[arg])
+        
+        if len(args) > 1:
+            return tuple(values)
+        else:
+            return values[0]

UQPyL-2.1.3/UQPyL/sensibility/delta_test.py → uqpyl-2.1.5/UQPyL/analysis/delta.py

@@ -3,13 +3,13 @@ import numpy as np
 from scipy.spatial import KDTree
 from typing import Optional, Tuple
 
-from .saABC import SA
-from ..DoE import LHS, Sampler
-from ..problems import ProblemABC, Problem
-from ..utility import Scaler, Verbose
-from ..optimization import GA
+from .base import AnalysisABC
+from ..doe import LHS, Sampler
+from ..problem import ProblemABC, Problem
+from ..util import Scaler, Verbose
+from ..optimization.soea import GA
 
-class Delta_Test(SA):
+class DeltaTest(AnalysisABC):
     """
     -------------------------------------------------
     Delta Test
@@ -37,8 +37,10 @@ class Delta_Test(SA):
         [2] SALib, https://github.com/SALib/SALib
     -------------------------------------------------
     """
+    
+    name = "DeltaTest"
+    
     def __init__(self, scalers: Tuple[Optional[Scaler], Optional[Scaler]] = (None, None), 
-                 nNeighbors: int = 2,
                  verboseFlag: bool = True, logFlag: bool = False, saveFlag: bool = False):
         """
         Initialize the Delta Test method.
@@ -50,18 +52,11 @@ class Delta_Test(SA):
         :param saveFlag: bool - If True, saves the results to a file. Defaults to False.
         """
         
-        # Attributes indicating the types of sensitivity indices calculated
-        self.firstOrder = True
-        self.secondOrder = False
-        self.totalOrder = False
-        
         # Initialize the base class with provided scalers and flags
         super().__init__(scalers, verboseFlag, logFlag, saveFlag)
 
-        # Set the number of nearest neighbors for analysis
-        self.setParameters('nNeighbors', nNeighbors)
         
-    def sample(self, problem: Problem, N: int = 500, sampler: Sampler = LHS('classic')):
+    def sample(self, problem: Problem, N: int = 500, sampler: Sampler = LHS('classic'), seed: Optional[int] = None):
         """
         Generate a sample set for the Delta Test.
         --------------------------------------------------
@@ -72,16 +67,19 @@ class Delta_Test(SA):
         :return: np.ndarray - A 2D array of shape `(N, nInput)`, where `nInput` is the number of input variables.
         """
         
+        self.rng = np.random.default_rng(seed) if seed is not None else np.random.default_rng()
+        
         nInput = problem.nInput
         
         # Generate samples using the specified sampler
-        X = sampler.sample(N, nInput)
+        sampler_seed = self.rng.integers(1, 1000000)
+        X = sampler.sample(problem, N, seed = sampler_seed)
         
         # Transform the samples to the problem's input space
         return problem._transform_unit_X(X)
     
-    @Verbose.decoratorAnalyze
-    def analyze(self, problem, X: np.ndarray, Y: np.ndarray = None):
+    @Verbose.analyze
+    def analyze(self, problem, X: np.ndarray, Y: np.ndarray = None, target = 'objFunc', index = 'all', nNeighbors: int = 2):
         """
         Perform the Delta Test analysis on the input data.
         --------------------------------------------------
@@ -89,7 +87,10 @@ class Delta_Test(SA):
         :param X: np.ndarray - A 2D array of shape `(N, n_input)`, representing the input data for analysis.
         :param Y: np.ndarray - A 1D array of length `N` representing the output values corresponding to `X`. 
                   If None, it will be computed by evaluating the problem with `X`.
-                
+        :param target: str - The target of the analysis, set 'objFunc' or 'conFunc'. Defaults to 'objFunc'.
+        :param index: list - The index of the output variables to analyze. Defaults to 'all'.
+        :param nNeighbors: int - The number of nearest neighbors used in Delta Test estimation. Defaults to 2.
+        
         :return: Result - An object containing the sensitivity indices 'S1', 'S2', and 'ST', 
                           representing first-order, second-order, and total-order indices. 
                           You can use result.Si to get the sensitivity indices.
@@ -99,36 +100,38 @@ class Delta_Test(SA):
         self.setProblem(problem)
         
         # Retrieve the number of nearest neighbors for analysis
-        nNeighbors = self.getParaValue('nNeighbors')
+        self.setParaValue('nNeighbors', nNeighbors)
         
         # Evaluate the problem if Y is not provided
-        if Y is None:
-            Y = self.evaluate(X)
+        Y = self.check_Y(X, Y, target, index)
         
         # Scale the input and output data if scalers are provided
         X, Y = self.__check_and_scale_xy__(X, Y)
         nInput = problem.nInput
+        numY = Y.shape[1]
+        
+        outputLabel = "obj" if target == "objFunc" else "con"
+        
+        S1 = np.zeros((numY, nInput))
+        S1_scaled = np.zeros((numY, nInput))
+        row_label = [f"{outputLabel}{i+1}" for i in range(numY)]
+        col_label_1 = problem.xLabels
+        
+        for i in range(numY):
+            Y_i = Y[:, i:i+1]
+            base = self._cal_delta(X, Y_i, nNeighbors)
+            for j in range(nInput):
+                XSub = np.delete(X, [j], axis=1)
+                S1[i, j] = self._cal_delta(XSub, Y_i, nNeighbors)
+            S1_scaled[i] = S1[i] / np.sum(S1[i])
+
+        res = [('S1', S1, row_label, col_label_1, 'decsDim1'), ('S1_scale', S1_scaled, row_label, col_label_1, 'decsDim1')]
         
-        # Initialize an array to store first-order sensitivity indices
-        S1 = np.zeros(nInput)
-        
-        # Calculate the base Delta value
-        base = self._cal_delta(X, Y, nNeighbors)
-        
-        # Calculate first-order sensitivity indices for each input variable
-        for i in range(nInput):
-            XSub = np.delete(X, [i], axis=1)
-            S1[i] = self._cal_delta(XSub, Y, nNeighbors)
-        
-        # Adjust the sensitivity indices
-        S1 = S1 - base 
-        S1 = S1 - np.min(S1)
+        X, Y = self.__reverse_X_Y__(X, Y)
         
-        # Record the calculated sensitivity indices
-        self.record('S1', problem.xLabels, S1)
-        self.record('S1(scaled)', problem.xLabels, S1 / np.sum(S1))
+        self.recordResult(X, Y, res)
 
-        return self.result
+        return self.result.generateNetCDF()
     
     def findCombEA(self, problem, X: np.ndarray, Y: np.ndarray = None, 
                    FEs: int = 10000,