ropt-dakota 0.1.0__tar.gz

ropt_dakota-0.1.0/.github/workflows/static-checks.yml

@@ -0,0 +1,42 @@
+name: Run static checks
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  workflow_dispatch:
+  schedule:
+    - cron:  '43 1 * * 1'
+
+jobs:
+  static-checks:
+    runs-on: ubuntu-22.04
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10"]
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install ropt
+        python -m pip install .[test]
+    - name: Run ruff format
+      if: always()
+      run: |
+        python -m ruff format --check src/ropt_dakota tests
+    - name: Run ruff
+      if: always()
+      run: |
+        python -m ruff check src/ropt_dakota tests
+    - name: Run mypy
+      if: always()
+      run: |
+        python -m mypy src/ropt_dakota tests
+  

ropt_dakota-0.1.0/.github/workflows/tests.yml

@@ -0,0 +1,33 @@
+name: Run tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  workflow_dispatch:
+  schedule:
+    - cron:  '43 1 * * 1'
+
+jobs:
+  run-tests:
+    runs-on: ubuntu-22.04
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install ropt
+        python -m pip install pytest
+        python -m pip install .
+    - name: Run pytest
+      run: |
+        python -m pytest tests

ropt_dakota-0.1.0/.gitignore

@@ -0,0 +1,3 @@
+**/__pycache__/**
+src/**egg-info/**
+src/ropt_dakota/version.py

ropt_dakota-0.1.0/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.1
+Name: ropt-dakota
+Version: 0.1.0
+Summary: A Dakota optimizer plugin for ropt
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python
+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: Topic :: Scientific/Engineering
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: carolina
+Provides-Extra: test
+Requires-Dist: ruff; extra == "test"
+Requires-Dist: mypy; extra == "test"
+Requires-Dist: pytest; extra == "test"
+
+# A Dakota optimizer plugin for `ropt`
+This package installs a plugin for the `ropt` robust optimizer package, giving
+access to algorithms from the Dakota optimization package.
+
+
+## Dependencies
+This code has been tested with Python versions 3.8, 3.9, 3.10 and 3.11.
+
+The backend is based on the [Dakota](https://dakota.sandia.gov/) optimizer and
+depends on the [Carolina](https://github.com/equinor/Carolina) Python wrapper.
+
+
+## Installation
+```bash
+pip install ropt-dakota
+```

ropt_dakota-0.1.0/README-PyPI.md

@@ -0,0 +1,16 @@
+# A Dakota optimizer plugin for `ropt`
+This package installs a plugin for the `ropt` robust optimizer package, giving
+access to algorithms from the Dakota optimization package.
+
+
+## Dependencies
+This code has been tested with Python versions 3.8, 3.9, 3.10 and 3.11.
+
+The backend is based on the [Dakota](https://dakota.sandia.gov/) optimizer and
+depends on the [Carolina](https://github.com/equinor/Carolina) Python wrapper.
+
+
+## Installation
+```bash
+pip install ropt-dakota
+```

ropt_dakota-0.1.0/README.md

@@ -0,0 +1,26 @@
+# A Dakota optimizer plugin for `ropt`
+This package installs a plugin for the `ropt` robust optimizer package, giving
+access to algorithms from the Dakota optimization package.
+
+
+## Dependencies
+This code has been tested with Python versions 3.8, 3.9, 3.10 and 3.11.
+
+The backend is based on the [Dakota](https://dakota.sandia.gov/) optimizer and
+depends on the [Carolina](https://github.com/equinor/Carolina) Python wrapper.
+
+
+## Installation
+To install, enter the distribution directory and execute:
+
+```bash
+pip install .
+```
+
+## Running the tests
+To run the test suite, install the necessary dependencies and execute `pytest`:
+
+```bash
+pip install .[test]
+pytest
+```

ropt_dakota-0.1.0/pyproject.toml

@@ -0,0 +1,90 @@
+[build-system]
+requires = ["setuptools", "setuptools-scm"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ropt-dakota"
+description = "A Dakota optimizer plugin for ropt"
+readme = "README-PyPI.md"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
+    "Natural Language :: English",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering",
+]
+requires-python = ">=3.8"
+dynamic = ["version"]
+dependencies = ["numpy", "carolina"]
+
+[project.optional-dependencies]
+test = ["ruff", "mypy", "pytest"]
+
+[project.entry-points."ropt.plugins.optimizer"]
+dakota = "ropt_dakota.dakota:DakotaOptimizer"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["ropt_dakota"]
+
+[tool.setuptools.package-data]
+ropt_dakota = ["py.typed"]
+
+[tool.setuptools.dynamic]
+version = { attr = "ropt_dakota.version.__version__" }
+
+[tool.setuptools_scm]
+write_to = "src/ropt_dakota/version.py"
+
+[tool.pytest.ini_options]
+filterwarnings = [
+    "error",
+    'ignore:.*Pydantic will allow any object with no validation.*:UserWarning',          # 3.8
+]
+
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = [
+    "ANN101",
+    "ANN102",
+    "AIR",
+    "COM812",
+    "COM819",
+    "D206",
+    "E501",
+    "DJ",
+    "FA",
+    "ISC001",
+    "PGH",
+    "UP",
+    "ANN101",
+    "ANN102",
+    "FIX002",
+    "S101",
+    "TD002",
+    "TD003",
+    "Q",
+    "UP",
+    "W191",
+]
+
+[tool.ruff.format]
+exclude = ["src/ropt_dakota/version.py", "build"]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["D", "ANN401", "PLR2004"]
+
+[tool.mypy]
+strict = true
+
+[[tool.mypy.overrides]]
+module = ["dakota", "ropt_dakota.version"]
+ignore_missing_imports = true

ropt_dakota-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ropt_dakota-0.1.0/src/ropt_dakota/__init__.py

@@ -0,0 +1 @@
+"""A Dakota optimizer plugin for ropt."""

ropt_dakota-0.1.0/src/ropt_dakota/dakota.py

@@ -0,0 +1,468 @@
+"""This module implements the Dakota optimization plugin."""
+
+from math import isfinite
+from os import chdir
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from typing import Any, ClassVar, Dict, List, Optional, Set, Tuple
+
+import numpy as np
+from dakota import _USER_DATA, DakotaBase, DakotaInput, run_dakota
+from numpy.typing import NDArray
+from ropt.config.enopt import EnOptConfig, OptimizerConfig
+from ropt.enums import ConstraintType
+from ropt.exceptions import ConfigError
+from ropt.plugins.optimizer.protocol import OptimizerCallback
+from ropt.plugins.optimizer.utils import create_output_path, filter_linear_constraints
+
+_PRECISION: int = 8
+_LARGE_NUMBER_FOR_INF = 1e30
+
+_ConstraintIndices = Tuple[
+    NDArray[np.intc],
+    NDArray[np.intc],
+    NDArray[np.intc],
+]
+
+
+class DakotaOptimizer:
+    """Backend class for optimization via Dakota."""
+
+    SUPPORTED_ALGORITHMS: ClassVar[Set[str]] = {
+        "optpp_q_newton",
+        "conmin_mfd",
+        "conmin_frcg",
+        "mesh_adaptive_search",
+        "coliny_ea",
+        "soga",
+        "moga",
+        "asynch_pattern_search",
+    }
+
+    def __init__(
+        self, config: EnOptConfig, optimizer_callback: OptimizerCallback
+    ) -> None:
+        """Initialize the optimizer implemented by the Dakota plugin.
+
+        See the [ropt.plugins.optimizer.protocol.Optimizer][] protocol.
+
+        # noqa
+        """
+        self._config = config
+        self._optimizer_callback = optimizer_callback
+        self._constraint_indices = self._get_constraint_indices()
+        self._output_dir: Path
+
+    def start(self, initial_values: NDArray[np.float64]) -> None:
+        """Start the optimization.
+
+        See the [ropt.plugins.optimizer.protocol.Optimizer][] protocol.
+
+        # noqa
+        """
+        if self._config.optimizer.output_dir is None:
+            with TemporaryDirectory() as output_dir:
+                self._output_dir = Path(output_dir)
+                self._start(initial_values)
+        else:
+            self._output_dir = self._config.optimizer.output_dir
+            self._start(initial_values)
+
+    def _get_constraint_indices(self) -> Optional[_ConstraintIndices]:
+        if self._config.nonlinear_constraints is None:
+            return None
+        types = self._config.nonlinear_constraints.types
+        return (
+            np.fromiter(
+                (idx for idx, type_ in enumerate(types) if type_ == ConstraintType.LE),
+                dtype=np.intc,
+            ),
+            np.fromiter(
+                (idx for idx, type_ in enumerate(types) if type_ == ConstraintType.GE),
+                dtype=np.intc,
+            ),
+            np.fromiter(
+                (idx for idx, type_ in enumerate(types) if type_ == ConstraintType.EQ),
+                dtype=np.intc,
+            ),
+        )
+
+    def _get_inputs(self, initial_values: NDArray[np.float64]) -> Dict[str, List[str]]:
+        return {
+            "environment": [
+                "tabular_graphics_data",
+                "output_precision = 8",
+            ],
+            "method": self._get_method_section(),
+            "model": ["single"],
+            "variables": (
+                self._get_variables_section(initial_values)
+                + self._get_linear_constraints_section()
+            ),
+            "responses": [
+                "num_objective_functions = 1",
+                "analytic_gradients",
+                "no_hessians",
+                *self._get_responses_section(),
+            ],
+        }
+
+    def _get_method_section(self) -> List[str]:
+        inputs: List[str] = []
+        algorithm = self._config.optimizer.algorithm
+        if algorithm is None:
+            algorithm = "optpp_q_newton"
+        inputs.append(algorithm)
+        # Scaling is always on
+        inputs.append("scaling")
+        iterations = self._config.optimizer.max_iterations
+        if iterations is not None and algorithm != "asynch_pattern_search":
+            inputs.append(f"max_iterations = {iterations}")
+        convergence_tolerance = self._config.optimizer.tolerance
+        if convergence_tolerance is not None:
+            tolerance_option = (
+                "variable_tolerance"
+                if algorithm in ["mesh_adaptive_search", "asynch_pattern_search"]
+                else "convergence_tolerance"
+            )
+            inputs.append(f"{tolerance_option} = {convergence_tolerance}")
+        # The Dakota interface seems not be able to deal with with speculative
+        # and split_evaluations simultaneously. Do not enable speculative if
+        # split_evaluations is defined.
+        if (
+            self._config.optimizer.speculative
+            and not self._config.optimizer.split_evaluations
+        ):
+            inputs.append("speculative")
+        # Options are put in the method section:
+        return inputs + self._get_options(algorithm)
+
+    def _get_options(self, algorithm: str) -> List[str]:
+        inputs: List[str] = []
+        if isinstance(self._config.optimizer.options, list):
+            try:
+                for option in self._config.optimizer.options:
+                    stripped = option.strip()
+                    if stripped.startswith("input_file"):
+                        continue
+                    if algorithm in [
+                        "conmin_mfd",
+                        "conmin_frcg",
+                    ] and stripped.startswith("constraint_tolerance"):
+                        continue
+                    inputs.append(f"{option}")
+            except TypeError as exc:
+                msg = "Cannot parse Dakota optimization options"
+                raise ConfigError(msg) from exc
+        return inputs
+
+    def _get_variables_section(self, initial_values: NDArray[np.float64]) -> List[str]:
+        inputs: List[str] = []
+        names = self._config.variables.names
+        if names is None:
+            names = tuple(f"variable{idx}" for idx in range(initial_values.size))
+        lower_bounds = self._config.variables.lower_bounds
+        upper_bounds = self._config.variables.upper_bounds
+        variable_indices = self._config.variables.indices
+        if variable_indices is not None:
+            initial_values = initial_values[variable_indices]
+            names = tuple(names[idx] for idx in variable_indices)
+            lower_bounds = lower_bounds[variable_indices]
+            upper_bounds = upper_bounds[variable_indices]
+        inputs.append(f"continuous_design = {initial_values.size}")
+        inputs.append(
+            "initial_point "
+            + " ".join(
+                f"{initial_value:{_PRECISION}f}" for initial_value in initial_values
+            ),
+        )
+        inputs.append(
+            "lower_bounds "
+            + " ".join(
+                f"{bound:{_PRECISION}f}"
+                if isfinite(bound)
+                else f"-{_LARGE_NUMBER_FOR_INF}"
+                for bound in lower_bounds
+            ),
+        )
+        inputs.append(
+            "upper_bounds "
+            + " ".join(
+                f"{bound:{_PRECISION}f}"
+                if isfinite(bound)
+                else f"+{_LARGE_NUMBER_FOR_INF}"
+                for bound in upper_bounds
+            ),
+        )
+        variable_names = [
+            "_".join(str(name) for name in variable_name)
+            if isinstance(variable_name, tuple)
+            else str(variable_name)
+            for variable_name in names
+        ]
+        inputs.append(
+            "descriptors " + "  ".join(f"'{name}'" for name in variable_names),
+        )
+        return inputs
+
+    def _get_linear_constraints(
+        self,
+    ) -> Tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.ubyte]]:
+        linear_constraints_config = self._config.linear_constraints
+        assert linear_constraints_config is not None
+
+        if self._config.variables.indices is not None:
+            linear_constraints_config = filter_linear_constraints(
+                linear_constraints_config, self._config.variables.indices
+            )
+
+        coefficients = linear_constraints_config.coefficients
+        rhs_values = linear_constraints_config.rhs_values
+        types = linear_constraints_config.types
+
+        return coefficients, rhs_values, types
+
+    def _get_linear_constraints_section(self) -> List[str]:
+        inputs: List[str] = []
+
+        if self._config.linear_constraints is not None:
+            all_coefficients, all_rhs_values, all_types = self._get_linear_constraints()
+
+            coefficients = all_coefficients[all_types != ConstraintType.EQ, :]
+            rhs_values = all_rhs_values[all_types != ConstraintType.EQ]
+            rhs_values[rhs_values < -_LARGE_NUMBER_FOR_INF] = -_LARGE_NUMBER_FOR_INF
+            rhs_values[rhs_values > _LARGE_NUMBER_FOR_INF] = _LARGE_NUMBER_FOR_INF
+            types = all_types[all_types != ConstraintType.EQ]
+            if types.size > 0:
+                # Inequality linear constraints are defined as one-sided with a lower
+                # bound. Earlier versions of this driver used upper bounds, and we stick
+                # to that by using the negatives of the matrix and bound values for ge
+                # constraints.
+                coefficients[types == ConstraintType.GE, :] = -coefficients[
+                    types == ConstraintType.GE, :
+                ]
+                rhs_values[types == ConstraintType.GE] = -rhs_values[
+                    types == ConstraintType.GE
+                ]
+                # Add 0.0 to prevent -0.0 values:
+                coefficients += 0.0
+                rhs_values += 0.0
+                inputs.append(
+                    "linear_inequality_constraint_matrix = "
+                    + "\n".join(
+                        " ".join(
+                            f"{value:{_PRECISION}f}" for value in coefficients[idx, :]
+                        )
+                        for idx in range(types.size)
+                    ),
+                )
+                inputs.append(
+                    "linear_inequality_lower_bounds = "
+                    + " ".join(["-1e+30"] * types.size),
+                )
+                inputs.append(
+                    "linear_inequality_upper_bounds = "
+                    + " ".join(f"{value:{_PRECISION}f}" for value in rhs_values),
+                )
+
+            coefficients = all_coefficients[all_types == ConstraintType.EQ, :]
+            rhs_values = all_rhs_values[all_types == ConstraintType.EQ]
+            types = all_types[all_types == ConstraintType.EQ]
+            if types.size > 0:
+                inputs.append(
+                    "linear_equality_constraint_matrix = "
+                    + "\n".join(
+                        " ".join(
+                            f"{value:{_PRECISION}f}" for value in coefficients[idx, :]
+                        )
+                        for idx in range(types.size)
+                    ),
+                )
+                inputs.append(
+                    "linear_equality_targets ="
+                    + " ".join(f"{value:{_PRECISION}f}" for value in rhs_values),
+                )
+
+        return inputs
+
+    def _get_responses_section(self) -> List[str]:
+        inputs: List[str] = []
+        # ropt currently only allows for a single objective function
+        inputs.append("objective_function_scale_types 'value'")
+        inputs.append("objective_function_scales = 1.0")
+        if self._constraint_indices is not None:
+            ge_indices, le_indices, eq_indices = self._constraint_indices
+            ineq_count = ge_indices.size + le_indices.size
+            if ineq_count > 0:
+                inputs.append(f"nonlinear_inequality_constraints = {ineq_count} ")
+                inputs.append("nonlinear_inequality_upper_bounds" + " 0.0" * ineq_count)
+                inputs.append("nonlinear_inequality_scale_types 'value'")
+                inputs.append("nonlinear_inequality_scales" + " 1.0" * ineq_count)
+
+            eq_count = eq_indices.size
+            if eq_count > 0:
+                inputs.append(f"nonlinear_equality_constraints = {eq_count}")
+                inputs.append("nonlinear_equality_targets" + " 0.0" * eq_count)
+                inputs.append("nonlinear_equality_scale_types 'value'")
+                inputs.append("nonlinear_equality_scales" + " 1.0" * eq_count)
+        return inputs
+
+    def _start(self, initial_values: NDArray[np.float64]) -> None:
+        pwd = Path.cwd()
+        output_dir = create_output_path("dakota", self._output_dir)
+        output_dir.mkdir()
+        chdir(output_dir)
+
+        try:
+            self._start_direct_interface(initial_values)
+        finally:
+            if pwd.exists():
+                chdir(pwd)
+
+    def _start_direct_interface(self, initial_values: NDArray[np.float64]) -> None:
+        driver = _DakotaDriver(
+            self._config.optimizer,
+            self._optimizer_callback,
+            self._constraint_indices,
+            self._get_inputs(initial_values),
+        )
+        try:
+            driver.run_dakota(
+                infile="dakota_Input.in",
+                stdout="Report.txt",
+                stderr="dakota_errors.txt",
+            )
+        except Exception as err:
+            if driver.exception:
+                raise driver.exception from err
+            raise
+
+
+# mypy: disallow-subclassing-any=False
+class _DakotaDriver(DakotaBase):
+    def __init__(
+        self,
+        optimizer_config: OptimizerConfig,
+        optimizer_callback: OptimizerCallback,
+        constraint_indices: Optional[_ConstraintIndices],
+        inputs: Dict[str, List[str]],
+    ) -> None:
+        self._optimizer_config = optimizer_config
+        self._optimizer_callback = optimizer_callback
+        self._split_evaluations = optimizer_config.split_evaluations
+        self._constraint_indices = constraint_indices
+        self.exception: Optional[Exception] = None
+        super().__init__(DakotaInput(**inputs))
+
+    def dakota_callback(
+        self,
+        **kwargs: Any,  # noqa: ANN401
+    ) -> Dict[str, NDArray[np.float64]]:
+        try:
+            asv = [response for response in kwargs["asv"] if response > 0]
+            if len(set(asv)) > 1:
+                msg = "Non-unique ASV elements different from 0 are not yet supported."
+                raise NotImplementedError(msg)  # noqa: TRY301
+            return_functions = asv[0] in (1, 3)
+            compute_gradients = asv[0] in (2, 3)
+            function_result, gradient_result = _compute_response(
+                np.concatenate(
+                    (kwargs["cv"], kwargs["div"].astype(np.float64), kwargs["drv"]),
+                ),
+                self._constraint_indices,
+                self._optimizer_callback,
+                return_functions=return_functions,
+                compute_gradients=compute_gradients,
+                split_evaluations=self._split_evaluations,
+            )
+        except Exception as err:
+            self.exception = err
+            raise
+        # Store the return value.
+        retval = {}
+        if kwargs["asv"][0] & 1:
+            retval["fns"] = function_result
+        if kwargs["asv"][0] & 2:
+            retval["fnGrads"] = gradient_result
+        return retval
+
+    def run_dakota(  # noqa: PLR0913
+        self,
+        infile: str = "dakota.in",
+        stdout: Optional[str] = None,
+        stderr: Optional[str] = None,
+        restart: int = 0,
+        throw_on_error: bool = True,  # noqa: FBT001,FBT002
+    ) -> None:
+        overridden_infile = self._override_input_file()
+        if overridden_infile is None:
+            self.input.write_input(infile, driver_instance=self)
+        else:
+            lines = []
+            with Path(overridden_infile).open("r", encoding="utf-8") as fp_in:
+                for line in fp_in:
+                    idx = line.find("analysis_components")
+                    if idx >= 0:
+                        ident = str(id(self))
+                        _USER_DATA[ident] = self
+                        lines.append(line[:idx] + f"analysis_components = '{ident}'\n")
+                    else:
+                        lines.append(line)
+            with Path(infile).open("w", encoding="utf-8") as fp_out:
+                fp_out.writelines(lines)
+        run_dakota(infile, stdout, stderr, restart, throw_on_error)
+
+    def _override_input_file(self) -> Optional[str]:
+        input_file = None
+        if isinstance(self._optimizer_config.options, list):
+            input_file = next(
+                (
+                    option
+                    for option in self._optimizer_config.options
+                    if option.strip().startswith("input_file")
+                ),
+                None,
+            )
+        if input_file is not None:
+            split_input_file = input_file.split("=", 1)
+            if len(split_input_file) > 1:
+                path = Path(split_input_file[1].strip())
+                if path.is_file():
+                    return str(path)
+            msg = f"Invalid input_file option: {input_file}"
+            raise RuntimeError(msg)
+        return None
+
+
+def _compute_response(  # noqa: PLR0913
+    variables: NDArray[np.float64],
+    constraint_indices: Optional[_ConstraintIndices],
+    optimizer_callback: OptimizerCallback,
+    *,
+    return_functions: bool,
+    compute_gradients: bool,
+    split_evaluations: bool,
+) -> Tuple[NDArray[np.float64], NDArray[np.float64]]:
+    if return_functions and compute_gradients and split_evaluations:
+        functions, _ = optimizer_callback(
+            variables, return_functions=True, return_gradients=False
+        )
+        _, gradients = optimizer_callback(
+            variables, return_functions=False, return_gradients=True
+        )
+    else:
+        functions, gradients = optimizer_callback(
+            variables,
+            return_functions=return_functions,
+            return_gradients=compute_gradients,
+        )
+
+    # Reorder functions and gradients that correspond to nonlinear constraints:
+    if constraint_indices is not None:
+        ge_indices, le_indices, eq_indices = constraint_indices
+        indices = np.hstack((0, le_indices + 1, ge_indices + 1, eq_indices + 1))
+        if return_functions:
+            functions = functions[indices]
+        if compute_gradients:
+            gradients = gradients[indices, :]
+    return functions, gradients

ropt_dakota-0.1.0/src/ropt_dakota/version.py

@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)

ropt_dakota-0.1.0/src/ropt_dakota.egg-info/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.1
+Name: ropt-dakota
+Version: 0.1.0
+Summary: A Dakota optimizer plugin for ropt
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python
+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: Topic :: Scientific/Engineering
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: carolina
+Provides-Extra: test
+Requires-Dist: ruff; extra == "test"
+Requires-Dist: mypy; extra == "test"
+Requires-Dist: pytest; extra == "test"
+
+# A Dakota optimizer plugin for `ropt`
+This package installs a plugin for the `ropt` robust optimizer package, giving
+access to algorithms from the Dakota optimization package.
+
+
+## Dependencies
+This code has been tested with Python versions 3.8, 3.9, 3.10 and 3.11.
+
+The backend is based on the [Dakota](https://dakota.sandia.gov/) optimizer and
+depends on the [Carolina](https://github.com/equinor/Carolina) Python wrapper.
+
+
+## Installation
+```bash
+pip install ropt-dakota
+```

ropt_dakota-0.1.0/src/ropt_dakota.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+.gitignore
+README-PyPI.md
+README.md
+pyproject.toml
+.github/workflows/static-checks.yml
+.github/workflows/tests.yml
+src/ropt_dakota/__init__.py
+src/ropt_dakota/dakota.py
+src/ropt_dakota/py.typed
+src/ropt_dakota/version.py
+src/ropt_dakota.egg-info/PKG-INFO
+src/ropt_dakota.egg-info/SOURCES.txt
+src/ropt_dakota.egg-info/dependency_links.txt
+src/ropt_dakota.egg-info/entry_points.txt
+src/ropt_dakota.egg-info/requires.txt
+src/ropt_dakota.egg-info/top_level.txt
+tests/__init__.py
+tests/conftest.py
+tests/test_dakota_backend.py

ropt_dakota-0.1.0/src/ropt_dakota.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ropt_dakota-0.1.0/src/ropt_dakota.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[ropt.plugins.optimizer]
+dakota = ropt_dakota.dakota:DakotaOptimizer

ropt_dakota-0.1.0/src/ropt_dakota.egg-info/requires.txt

@@ -0,0 +1,7 @@
+numpy
+carolina
+
+[test]
+ruff
+mypy
+pytest

ropt_dakota-0.1.0/src/ropt_dakota.egg-info/top_level.txt

@@ -0,0 +1 @@
+ropt_dakota

ropt_dakota-0.1.0/tests/conftest.py

@@ -0,0 +1,72 @@
+from functools import partial
+from typing import Any, Callable, List, Tuple
+
+import numpy as np
+import pytest
+from numpy.typing import NDArray
+from ropt.evaluator import Evaluator, EvaluatorContext, EvaluatorResult
+
+_Function = Callable[[NDArray[np.float64]], float]
+
+
+def _function_runner(
+    variables: NDArray[np.float64],
+    metadata: EvaluatorContext,
+    functions: List[_Function],
+) -> EvaluatorResult:
+    objective_count = metadata.config.objective_functions.weights.size
+    constraint_count = (
+        0
+        if metadata.config.nonlinear_constraints is None
+        else metadata.config.nonlinear_constraints.rhs_values.size
+    )
+    objective_results = np.zeros(
+        (variables.shape[0], objective_count), dtype=np.float64
+    )
+    constraint_results = (
+        np.zeros((variables.shape[0], constraint_count), dtype=np.float64)
+        if constraint_count > 0
+        else None
+    )
+    for sim, realization in enumerate(metadata.realizations):
+        for idx in range(objective_count):
+            if (
+                metadata.active_objectives is None
+                or metadata.active_objectives[idx, realization]
+            ):
+                function = functions[idx]
+                objective_results[sim, idx] = function(variables[sim, :])
+        for idx in range(constraint_count):
+            if (
+                metadata.active_constraints is None
+                or metadata.active_constraints[idx, realization]
+            ):
+                function = functions[idx + objective_count]
+                assert constraint_results is not None
+                constraint_results[sim, idx] = function(variables[sim, :])
+    return EvaluatorResult(
+        objectives=objective_results,
+        constraints=constraint_results,
+    )
+
+
+def _compute_distance_squared(
+    variables: NDArray[np.float64], target: NDArray[np.float64]
+) -> float:
+    return float(((variables - target) ** 2).sum())
+
+
+@pytest.fixture(name="test_functions", scope="session")
+def fixture_test_functions() -> Tuple[_Function, _Function]:
+    return (
+        partial(_compute_distance_squared, target=[0.5, 0.5, 0.5]),
+        partial(_compute_distance_squared, target=[-1.5, -1.5, 0.5]),
+    )
+
+
+@pytest.fixture(scope="session")
+def evaluator(test_functions: Any) -> Callable[[List[_Function]], Evaluator]:
+    def _evaluator(test_functions: List[_Function] = test_functions) -> Evaluator:
+        return partial(_function_runner, functions=test_functions)
+
+    return _evaluator

ropt_dakota-0.1.0/tests/test_dakota_backend.py

@@ -0,0 +1,369 @@
+from functools import partial
+from pathlib import Path
+from typing import Any, Dict, cast
+
+import numpy as np
+import pytest
+from numpy.typing import NDArray
+from ropt.enums import ConstraintType, EventType, OptimizerExitCode
+from ropt.events import OptimizationEvent
+from ropt.optimization import EnsembleOptimizer
+from ropt.results import GradientResults
+from ropt_dakota.dakota import DakotaOptimizer
+
+
+@pytest.fixture(name="enopt_config")
+def enopt_config_fixture() -> Dict[str, Any]:
+    return {
+        "variables": {
+            "initial_values": [0.0, 0.0, 0.1],
+        },
+        "optimizer": {
+            "backend": "dakota",
+            "tolerance": 1e-6,
+        },
+        "objective_functions": {
+            "weights": [0.75, 0.25],
+        },
+        "gradient": {
+            "perturbation_magnitudes": 0.01,
+        },
+    }
+
+
+def test_dakota_unconstrained(enopt_config: Any, evaluator: Any) -> None:
+    optimizer = EnsembleOptimizer(evaluator())
+    result = optimizer.start_optimization(
+        plan=[
+            {"config": enopt_config},
+            {"optimizer": {"id": "opt"}},
+            {"tracker": {"id": "optimum", "source": "opt"}},
+        ],
+    )
+    assert result is not None
+    assert np.allclose(result.evaluations.variables, [0.0, 0.0, 0.5], atol=0.02)
+
+
+def test_dakota_option(enopt_config: Any, evaluator: Any) -> None:
+    enopt_config["optimizer"]["options"] = ["max_iterations = 0"]
+    optimizer = EnsembleOptimizer(evaluator())
+    result = optimizer.start_optimization(
+        plan=[
+            {"config": enopt_config},
+            {"optimizer": {"id": "opt"}},
+            {"tracker": {"id": "optimum", "source": "opt"}},
+        ],
+    )
+    assert result is not None
+    assert np.allclose(
+        result.evaluations.variables,
+        enopt_config["variables"]["initial_values"],
+        atol=0.02,
+    )
+
+
+@pytest.mark.parametrize(
+    # The conmin algorithms are not tested, since they produce some output to
+    # the terminal that we are not able to suppress. The soga method crashes
+    # occasionally.
+    "method",
+    sorted(
+        DakotaOptimizer.SUPPORTED_ALGORITHMS - {"conmin_mfd", "conmin_frcg", "soga"}
+    ),
+)
+def test_dakota_bound_constraint(
+    enopt_config: Any, method: str, evaluator: Any
+) -> None:
+    enopt_config["optimizer"]["algorithm"] = method
+    enopt_config["variables"]["lower_bounds"] = -1.0
+    enopt_config["variables"]["upper_bounds"] = [1.0, 1.0, 0.2]
+
+    optimizer = EnsembleOptimizer(evaluator())
+    result = optimizer.start_optimization(
+        plan=[
+            {"config": enopt_config},
+            {"optimizer": {"id": "opt"}},
+            {"tracker": {"id": "optimum", "source": "opt"}},
+        ],
+    )
+    assert result is not None
+    # Some methods do not easily convert, we just test if the ran:
+    if method not in ("coliny_ea", "moga"):
+        assert np.allclose(result.evaluations.variables, [0.0, 0.0, 0.2], atol=0.02)
+
+
+def test_dakota_eq_linear_constraint(enopt_config: Any, evaluator: Any) -> None:
+    enopt_config["linear_constraints"] = {
+        "coefficients": [[1, 0, 1], [0, 1, 1]],
+        "rhs_values": [1.0, 0.75],
+        "types": [ConstraintType.EQ, ConstraintType.EQ],
+    }
+
+    optimizer = EnsembleOptimizer(evaluator())
+    result = optimizer.start_optimization(
+        plan=[
+            {"config": enopt_config},
+            {"optimizer": {"id": "opt"}},
+            {"tracker": {"id": "optimum", "source": "opt"}},
+        ],
+    )
+    assert result is not None
+    assert np.allclose(result.evaluations.variables, [0.25, 0.0, 0.75], atol=0.02)
+
+
+def test_dakota_ge_linear_constraint(enopt_config: Any, evaluator: Any) -> None:
+    enopt_config["linear_constraints"] = {
+        "coefficients": [[-1, 0, -1]],
+        "rhs_values": -0.4,
+        "types": [ConstraintType.GE],
+    }
+
+    optimizer = EnsembleOptimizer(evaluator())
+    result = optimizer.start_optimization(
+        plan=[
+            {"config": enopt_config},
+            {"optimizer": {"id": "opt"}},
+            {"tracker": {"id": "optimum", "source": "opt"}},
+        ],
+    )
+    assert result is not None
+    assert np.allclose(result.evaluations.variables, [-0.05, 0.0, 0.45], atol=0.02)
+
+
+def test_dakota_le_linear_constraint(enopt_config: Any, evaluator: Any) -> None:
+    enopt_config["linear_constraints"] = {
+        "coefficients": [[1, 0, 1]],
+        "rhs_values": 0.4,
+        "types": [ConstraintType.LE],
+    }
+
+    optimizer = EnsembleOptimizer(evaluator())
+    result = optimizer.start_optimization(
+        plan=[
+            {"config": enopt_config},
+            {"optimizer": {"id": "opt"}},
+            {"tracker": {"id": "optimum", "source": "opt"}},
+        ],
+    )
+    assert result is not None
+    assert np.allclose(result.evaluations.variables, [-0.05, 0.0, 0.45], atol=0.02)
+
+
+def test_dakota_le_ge_linear_constraints(enopt_config: Any, evaluator: Any) -> None:
+    enopt_config["linear_constraints"] = {
+        "coefficients": [[1, 0, 1], [-1, 0, -1]],
+        "rhs_values": [0.4, -0.4],
+        "types": [ConstraintType.LE, ConstraintType.GE],
+    }
+
+    optimizer = EnsembleOptimizer(evaluator())
+    result = optimizer.start_optimization(
+        plan=[
+            {"config": enopt_config},
+            {"optimizer": {"id": "opt"}},
+            {"tracker": {"id": "optimum", "source": "opt"}},
+        ],
+    )
+    assert result is not None
+    assert np.allclose(result.evaluations.variables, [-0.05, 0.0, 0.45], atol=0.02)
+
+
+def test_dakota_eq_nonlinear_constraint(
+    enopt_config: Any, evaluator: Any, test_functions: Any
+) -> None:
+    enopt_config["nonlinear_constraints"] = {
+        "rhs_values": 1.0,
+        "types": [ConstraintType.EQ],
+    }
+    test_functions = (
+        *test_functions,
+        lambda variables: cast(NDArray[np.float64], variables[0] + variables[2]),
+    )
+
+    optimizer = EnsembleOptimizer(evaluator(test_functions))
+    result = optimizer.start_optimization(
+        plan=[
+            {"config": enopt_config},
+            {"optimizer": {"id": "opt"}},
+            {"tracker": {"id": "optimum", "source": "opt"}},
+        ],
+    )
+    assert result is not None
+    assert np.allclose(result.evaluations.variables, [0.25, 0.0, 0.75], atol=0.02)
+
+
+@pytest.mark.parametrize("bound_type", [ConstraintType.LE, ConstraintType.GE])
+def test_dakota_ineq_nonlinear_constraint(
+    enopt_config: Any,
+    bound_type: ConstraintType,
+    evaluator: Any,
+    test_functions: Any,
+) -> None:
+    enopt_config["nonlinear_constraints"] = {
+        "rhs_values": 0.4 if bound_type == ConstraintType.LE else -0.4,
+        "types": [bound_type],
+    }
+    weight = 1.0 if bound_type == ConstraintType.LE else -1.0
+    test_functions = (
+        *test_functions,
+        lambda variables: cast(
+            NDArray[np.float64], weight * variables[0] + weight * variables[2]
+        ),
+    )
+
+    optimizer = EnsembleOptimizer(evaluator(test_functions))
+    result = optimizer.start_optimization(
+        plan=[
+            {"config": enopt_config},
+            {"optimizer": {"id": "opt"}},
+            {"tracker": {"id": "optimum", "source": "opt"}},
+        ],
+    )
+    assert result is not None
+    assert np.allclose(result.evaluations.variables, [-0.05, 0.0, 0.45], atol=0.02)
+
+
+def test_dakota_failed_realizations(enopt_config: Any, evaluator: Any) -> None:
+    def func_p(_0: NDArray[np.float64]) -> float:
+        return 1.0
+
+    def func_q(_0: NDArray[np.float64]) -> float:
+        return np.nan
+
+    functions = [func_p, func_q]
+
+    def handle_finished(event: OptimizationEvent) -> None:
+        assert event.exit_code == OptimizerExitCode.TOO_FEW_REALIZATIONS
+
+    optimizer = EnsembleOptimizer(evaluator(functions))
+    optimizer.add_observer(EventType.FINISHED_OPTIMIZER_STEP, handle_finished)
+    optimizer.start_optimization([{"config": enopt_config}, {"optimizer": {}}])
+
+
+def test_dakota_user_abort(enopt_config: Any, evaluator: Any) -> None:
+    optimizer = EnsembleOptimizer(evaluator())
+
+    def observer(event: OptimizationEvent, optimizer: EnsembleOptimizer) -> None:
+        assert event.results is not None
+        if event.results[0].result_id == 2:
+            optimizer.abort_optimization()
+
+    def handle_finished(event: OptimizationEvent) -> None:
+        assert event.exit_code == OptimizerExitCode.USER_ABORT
+
+    optimizer.add_observer(
+        EventType.FINISHED_EVALUATION, partial(observer, optimizer=optimizer)
+    )
+    optimizer.add_observer(EventType.FINISHED_OPTIMIZER_STEP, handle_finished)
+    result = optimizer.start_optimization(
+        plan=[
+            {"config": enopt_config},
+            {"optimizer": {"id": "opt"}},
+            {"tracker": {"id": "optimum", "source": "opt"}},
+        ],
+    )
+    assert result is not None
+    assert result.result_id == 2
+
+
+def test_dakota_split_evaluations(enopt_config: Any, evaluator: Any) -> None:
+    enopt_config["optimizer"]["split_evaluations"] = True
+
+    optimizer = EnsembleOptimizer(evaluator())
+    result = optimizer.start_optimization(
+        plan=[
+            {"config": enopt_config},
+            {"optimizer": {"id": "opt"}},
+            {"tracker": {"id": "optimum", "source": "opt"}},
+        ],
+    )
+    assert result is not None
+    assert np.allclose(result.evaluations.variables, [0.0, 0.0, 0.5], atol=0.02)
+    enopt_config["optimizer"]["split_evaluations"] = True
+    enopt_config["optimizer"]["speculative"] = True
+
+    optimizer = EnsembleOptimizer(evaluator())
+    result = optimizer.start_optimization(
+        plan=[
+            {"config": enopt_config},
+            {"optimizer": {"id": "opt"}},
+            {"tracker": {"id": "optimum", "source": "opt"}},
+        ],
+    )
+    assert result is not None
+    assert np.allclose(result.evaluations.variables, [0.0, 0.0, 0.5], atol=0.02)
+
+
+def test_dakota_optimizer_variables_subset(enopt_config: Any, evaluator: Any) -> None:
+    enopt_config["variables"]["initial_values"] = [0.0, 0.0, 0.1]
+    enopt_config["variables"]["lower_bounds"] = -1.0
+    enopt_config["variables"]["upper_bounds"] = 1.0
+
+    # Fix the second variables, the test function still has the same optimal
+    # values for the other parameters:
+    enopt_config["variables"]["indices"] = [0, 2]
+
+    def assert_gradient(event: OptimizationEvent) -> None:
+        assert event.results is not None
+        for item in event.results:
+            if isinstance(item, GradientResults):
+                assert item.gradients is not None
+                assert item.gradients.weighted_objective[1] == 0.0
+                assert np.all(np.equal(item.gradients.objectives[:, 1], 0.0))
+
+    optimizer = EnsembleOptimizer(evaluator())
+    optimizer.add_observer(EventType.FINISHED_EVALUATION, assert_gradient)
+    result = optimizer.start_optimization(
+        plan=[
+            {"config": enopt_config},
+            {"optimizer": {"id": "opt"}},
+            {"tracker": {"id": "optimum", "source": "opt"}},
+        ],
+    )
+    assert result is not None
+    assert np.allclose(result.evaluations.variables, [0.0, 0.0, 0.5], atol=0.02)
+
+
+def test_dakota_optimizer_variables_subset_linear_constraints(
+    enopt_config: Any, evaluator: Any
+) -> None:
+    # Set the second variable a constant value, this will not affect the
+    # optimization of the other variables in this particular test problem:
+    enopt_config["variables"]["initial_values"] = [0.0, 1.0, 0.1]
+    # The second and third constraints are dropped because they involve
+    # variables that are not optimized. They are still checked by the monitor:
+    enopt_config["linear_constraints"] = {
+        "coefficients": [[1, 0, 1], [0, 1, 0], [1, 1, 1]],
+        "rhs_values": [1.0, 1.0, 2.0],
+        "types": [ConstraintType.EQ, ConstraintType.EQ, ConstraintType.EQ],
+    }
+    enopt_config["variables"]["indices"] = [0, 2]
+
+    optimizer = EnsembleOptimizer(evaluator())
+    result = optimizer.start_optimization(
+        plan=[
+            {"config": enopt_config},
+            {"optimizer": {"id": "opt"}},
+            {"tracker": {"id": "optimum", "source": "opt"}},
+        ],
+    )
+    assert result is not None
+    assert np.allclose(result.evaluations.variables, [0.25, 1.0, 0.75], atol=0.02)
+
+
+def test_dakota_output_dir(tmp_path: Path, enopt_config: Any, evaluator: Any) -> None:
+    output_dir = tmp_path / "outputdir"
+    output_dir.mkdir()
+    enopt_config["optimizer"]["output_dir"] = output_dir
+    enopt_config["optimizer"]["max_functions"] = 1
+
+    optimizer = EnsembleOptimizer(evaluator())
+    optimizer.start_optimization([{"config": enopt_config}, {"optimizer": {}}])
+    assert (output_dir / "dakota").exists()
+
+    optimizer = EnsembleOptimizer(evaluator())
+    optimizer.start_optimization([{"config": enopt_config}, {"optimizer": {}}])
+    assert (output_dir / "dakota-001").exists()
+    optimizer = EnsembleOptimizer(evaluator())
+    optimizer.start_optimization([{"config": enopt_config}, {"optimizer": {}}])
+    assert (output_dir / "dakota-002").exists()