From ecb4aef1b885d44eec2666a2e22897e3718444f9 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Wed, 4 Dec 2024 07:37:53 -0500
Subject: [PATCH 001/143] trying to test grey box

Issue on windows, uploading file to test on mac
---
 pyomo/contrib/doe/examples/grey_box_test.py | 333 ++++++++++++++++++++
 1 file changed, 333 insertions(+)
 create mode 100644 pyomo/contrib/doe/examples/grey_box_test.py

diff --git a/pyomo/contrib/doe/examples/grey_box_test.py b/pyomo/contrib/doe/examples/grey_box_test.py
new file mode 100644
index 00000000000..f57270679ed
--- /dev/null
+++ b/pyomo/contrib/doe/examples/grey_box_test.py
@@ -0,0 +1,333 @@
+import numpy as np
+import pyomo.environ as pyo
+from scipy.sparse import coo_matrix
+from pyomo.contrib.pynumero.interfaces.external_grey_box import ExternalGreyBoxModel, ExternalGreyBoxBlock
+
+import inspect
+from pathlib import Path
+
+
+try:
+    inspect.stack()[1]
+    print(Path(inspect.stack()[1].filename).absolute)
+except:
+    print("No stack()[1]...")
+
+class LogDetModel(ExternalGreyBoxModel):
+    def __init__(
+        self,
+        n_parameters=2,
+        initial_fim=None,
+        use_exact_derivatives=True,
+        print_level=0,
+    ):
+        """
+        Greybox model to compute the log determinant of a sqaure symmetric matrix.
+
+        Arguments
+        ---------
+        n_parameters: int
+            Number of parameters in the model. The square symmetric matrix is of shape n_parameters*n_parameters
+        initial_fim: dict
+            key: tuple (i,j) where i, j are the row, column number of FIM. value: FIM[i,j] 
+            Initial value of the matrix. If None, the identity matrix is used.
+        use_exact_derivatives: bool
+            If True, the exact derivatives are used.
+            If False, the finite difference approximation can be used, but not recommended/tested.
+        print_level: integer
+            0 (default): no extra output
+            1: minimal info to indicate if initialized well
+                print the following:
+                - initial FIM received by the grey-box moduel
+            2: intermediate info for debugging
+                print all the level 1 print statements, plus:
+                - the FIM output of the current iteration, both the output as the FIM matrix, and the flattened vector
+            3: all details for debugging
+                print all the level 2 print statements, plus:
+                - the log determinant of the FIM output of the current iteration
+                - the eigen values of the FIM output of the current iteration
+
+        Return
+        ------
+        None
+        """
+        trash = input(str(inspect.stack()[0][3]))
+
+        self._use_exact_derivatives = use_exact_derivatives
+        self.print_level = print_level
+        self.n_parameters = n_parameters
+        # make sure it's integer since this is a number of inputs that shouldn't be fractional
+        self.num_input = int(
+            n_parameters + (n_parameters * n_parameters - n_parameters) / 2
+        )
+        self.initial_fim = initial_fim
+
+        # variable to store the output value
+        # Output constraint multiplier values. This is a 1-element vector because there is one output
+        self._output_con_mult_values = np.zeros(1)
+
+        if not use_exact_derivatives:
+            raise NotImplementedError("use_exact_derivatives == False not supported")
+
+    def input_names(self):
+        """Return the names of the inputs.
+        Define only the upper triangle of FIM because FIM is symmetric
+
+        Return
+        ------
+        input_name_list: a list of the names of inputs
+        """
+        #trash = input(str(inspect.stack()[0][3]))
+
+        # store the input names as a tuple 
+        input_name_list = []
+        # loop over parameters
+        for i in range(self.n_parameters):
+            # loop over upper triangle
+            for j in range(i, self.n_parameters):
+                input_name_list.append((i, j))
+
+        return input_name_list
+
+    def equality_constraint_names(self):
+        """Return the names of the equality constraints."""
+        # no equality constraints
+        #trash = input(str(inspect.stack()[0][3]))
+        return []
+
+    def output_names(self):
+        """Return the names of the outputs."""
+        #trash = input(str(inspect.stack()[0][3]))
+        return ["log_det"]
+
+    def set_output_constraint_multipliers(self, output_con_multiplier_values):
+        """
+        Set the values of the output constraint multipliers.
+
+        Arguments
+        ---------
+        output_con_multiplier_values: a scalar number for the output constraint multipliers
+        """
+        #trash = input(str(inspect.stack()[0][3]))
+
+        # because we only have one output constraint, the length is 1
+        if len(output_con_multiplier_values) != 1:
+            raise ValueError("Output should be a scalar value. ")
+
+        np.copyto(self._output_con_mult_values, output_con_multiplier_values)
+
+    def finalize_block_construction(self, pyomo_block):
+        """
+        Finalize the construction of the ExternalGreyBoxBlock.
+        This function initializes the inputs with an initial value
+
+        Arguments
+        ---------
+        pyomo_block: pass the created pyomo block here
+        """
+        # ele_to_order map the input position in FIM, like (a,b), to its flattend index
+        # for e.g., ele_to_order[(0,0)] = 0
+        #trash = input(str(inspect.stack()[0][3]))
+
+        ele_to_order = {}
+        count = 0
+
+        if self.print_level >= 1:
+            if self.initial_fim is not None:
+                print("Grey-box initialize inputs with: ", self.initial_fim)
+            else:
+                print("Grey-box initialize inputs with an identity matrix.")
+
+        # only generating upper triangular part
+        # loop over parameters
+        for i in range(self.n_parameters):
+            # loop over parameters from current parameter to end
+            for j in range(i, self.n_parameters):
+                # flatten (i,j)
+                ele_to_order[(i, j)] = count
+                # this tuple is the position of this input in the FIM
+                tuple_name = (i, j)
+
+                # if an initial FIM is given, we can initialize with these values
+                if self.initial_fim is not None:
+                    pyomo_block.inputs[tuple_name].value = self.initial_fim[tuple_name]
+
+                # if not given initial FIM, we initialize with an identity matrix
+                else:
+                    # identity matrix
+                    if i == j:
+                        pyomo_block.inputs[tuple_name].value = 1
+                    else:
+                        pyomo_block.inputs[tuple_name].value = 0
+
+                count += 1
+
+        self.ele_to_order = ele_to_order
+
+    def set_input_values(self, input_values):
+        """
+        Set the values of the inputs.
+        This function refers to the notebook: 
+        https://colab.research.google.com/drive/1VplaeOTes87oSznboZXoz-q5W6gKJ9zZ?usp=sharing
+
+        Arguments
+        ---------
+        input_values: input initial values
+        """
+        # see the colab link in the doc string for why this should be a list 
+        self._input_values = list(input_values)
+
+        #trash = input(str(inspect.stack()[0][3]))
+
+    def evaluate_equality_constraints(self):
+        """Evaluate the equality constraints.
+        Return None because there are no equality constraints.
+        """
+        trash = input(str(inspect.stack()[0][3]))
+
+        return None
+
+    def evaluate_outputs(self):
+        """
+        Evaluate the output of the model.
+        We call numpy here to compute the logdet of FIM. slogdet is used to avoid ill-conditioning issue
+        This function refers to the notebook: 
+        https://colab.research.google.com/drive/1VplaeOTes87oSznboZXoz-q5W6gKJ9zZ?usp=sharing
+
+        Return
+        ------
+        logdet: a one-element numpy array, containing the log det value as float
+        """
+        #trash = input(str(inspect.stack()[0][3]))
+
+        # form matrix as a list of lists
+        M = self._extract_and_assemble_fim()
+
+        # compute log determinant
+        (sign, logdet) = np.linalg.slogdet(M)
+
+        if self.print_level >= 2:
+            print("iteration")
+            print("\n Consider M =\n", M)
+            print("Solution: ", self._input_values)
+            if self.print_level == 3:
+                print("   logdet = ", logdet, "\n")
+                print("Eigvals:", np.linalg.eigvals(M))
+
+        # see the colab link in the doc string for why this should be a array with dtype as float64
+        return np.asarray([logdet], dtype=np.float64)
+
+    def evaluate_jacobian_equality_constraints(self):
+        """Evaluate the Jacobian of the equality constraints."""
+        #trash = input(str(inspect.stack()[0][3]))
+        return None
+
+    def _extract_and_assemble_fim(self):
+        """
+        This function make the flattened inputs back into the shape of an FIM
+
+        Return
+        ------
+        M: a numpy array containing FIM.
+        """
+        #trash = input(str(inspect.stack()[0][3]))
+
+        # FIM shape Np*Np
+        M = np.zeros((self.n_parameters, self.n_parameters))
+        # loop over parameters.
+        # Expand here to be the full matrix.
+        for i in range(self.n_parameters):
+            for k in range(self.n_parameters):
+                #  get symmetry part.
+                # only have upper triangle, so the smaller index is the row number
+                row_number, col_number = min(i, k), max(i, k)
+                M[i, k] = self._input_values[
+                    self.ele_to_order[(row_number, col_number)]
+                ]
+
+        return M
+
+    def evaluate_jacobian_outputs(self):
+        """
+        Evaluate the Jacobian of the outputs.
+
+        Return
+        ------
+        A sparse matrix, containing the first order gradient of the OBJ, in the shape [1,N_input]
+        where N_input is the No. of off-diagonal elements//2 + Np
+        """
+        #trash = input(str(inspect.stack()[0][3]))
+
+        if self._use_exact_derivatives:
+            M = self._extract_and_assemble_fim()
+
+            # compute pseudo inverse to be more numerically stable
+            Minv = np.linalg.pinv(M)
+
+            # compute gradient of log determinant
+            row = np.zeros(self.num_input)  # to store row index
+            col = np.zeros(self.num_input)  # to store column index
+            data = np.zeros(self.num_input)  # to store data
+
+            # construct gradients as a sparse matrix
+            # loop over the upper triangular
+            # loop over parameters
+            for i in range(self.n_parameters):
+                # loop over parameters from current parameter to end
+                for j in range(i, self.n_parameters):
+                    order = self.ele_to_order[(i, j)]
+                    # diagonal elements. See Eq. 16 in paper for explanation
+                    if i == j:
+                        row[order], col[order], data[order] = (0, order, Minv[i, j])
+                    # off-diagonal elements
+                    else:  # factor = 2 since it is a symmetric matrix. See Eq. 16 in paper for explanation
+                        row[order], col[order], data[order] = (0, order, 2 * Minv[i, j])
+            # sparse matrix
+            return coo_matrix((data, (row, col)), shape=(1, self.num_input))
+        
+
+import idaes
+
+m = pyo.ConcreteModel()
+m.params = pyo.Set(initialize=[0, 1])
+m.params_mat = m.params * m.params
+m.M = pyo.Var(m.params_mat, bounds=(0, 50), initialize=1)
+
+print('Made base model.')
+
+ex_model = LogDetModel(
+            n_parameters=2,
+            initial_fim=None,
+            #initial_fim=np.ones((2, 2)),
+            print_level=1,
+        )
+
+print('Added logdet model')
+m.egb = ExternalGreyBoxBlock(external_model=ex_model)
+
+print('Added as external grey box.')
+
+# constraining outputs
+m.M_con1 = pyo.Constraint(expr=(m.M[(0,0)] == m.egb.inputs[(0,0)]))
+m.M_con2 = pyo.Constraint(expr=(m.M[(0,1)] == m.egb.inputs[(0,1)]))
+m.M_con3 = pyo.Constraint(expr=(m.M[(1,1)] == m.egb.inputs[(1,1)]))
+m.M_con4 = pyo.Constraint(expr=(m.M[(1,0)] == m.M[(0,1)]))
+
+print('Added constraints on symmetry for FIM.')
+
+m.logdet = pyo.Expression(rule=m.egb.outputs["log_det"])
+
+m.obj = pyo.Objective(expr=m.logdet, sense=pyo.maximize)
+
+print('Added objective function. Solve is next action.')
+
+solver = pyo.SolverFactory("cyipopt")
+solver.config.options['hessian_approximation'] = 'limited-memory'
+#solver.config.options['mu_strategy'] = 'monotone'
+#solver.config.options['linear_solver'] = 'ma27'
+
+solver.solve(m, tee=True)
+
+m.M.pprint()
+
+#m.pprint()

From c9340d798161d41d599a35bc1a02bc23a873aff6 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Wed, 4 Dec 2024 07:58:15 -0500
Subject: [PATCH 002/143] Confirmed code works fine on Mac

Windows-specific issue with the code; will report issue in due time.
---
 pyomo/contrib/doe/examples/grey_box_test.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyomo/contrib/doe/examples/grey_box_test.py b/pyomo/contrib/doe/examples/grey_box_test.py
index f57270679ed..26109f13ff6 100644
--- a/pyomo/contrib/doe/examples/grey_box_test.py
+++ b/pyomo/contrib/doe/examples/grey_box_test.py
@@ -286,7 +286,7 @@ def evaluate_jacobian_outputs(self):
             return coo_matrix((data, (row, col)), shape=(1, self.num_input))
         
 
-import idaes
+# import idaes
 
 m = pyo.ConcreteModel()
 m.params = pyo.Set(initialize=[0, 1])

From ab2f06f8ceb4f81122e096fd81407ab3804ad902 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 5 Dec 2024 10:58:40 -0500
Subject: [PATCH 003/143] Added skeleton for grey box

Used all phrases for ExternalGreyBoxModel.

Need to make more robust the naming and bookkeeping for input names and subsequently the coo matrices.
---
 pyomo/contrib/doe/grey_box_utilities.py | 169 ++++++++++++++++++++++++
 1 file changed, 169 insertions(+)
 create mode 100644 pyomo/contrib/doe/grey_box_utilities.py

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
new file mode 100644
index 00000000000..c17ec5ebbf2
--- /dev/null
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -0,0 +1,169 @@
+#  ___________________________________________________________________________
+#
+#  Pyomo: Python Optimization Modeling Objects
+#  Copyright (c) 2008-2024
+#  National Technology and Engineering Solutions of Sandia, LLC
+#  Under the terms of Contract DE-NA0003525 with National Technology and
+#  Engineering Solutions of Sandia, LLC, the U.S. Government retains certain
+#  rights in this software.
+#  This software is distributed under the 3-clause BSD License.
+#
+#  Pyomo.DoE was produced under the Department of Energy Carbon Capture Simulation
+#  Initiative (CCSI), and is copyright (c) 2022 by the software owners:
+#  TRIAD National Security, LLC., Lawrence Livermore National Security, LLC.,
+#  Lawrence Berkeley National Laboratory, Pacific Northwest National Laboratory,
+#  Battelle Memorial Institute, University of Notre Dame,
+#  The University of Pittsburgh, The University of Texas at Austin,
+#  University of Toledo, West Virginia University, et al. All rights reserved.
+#
+#  NOTICE. This Software was developed under funding from the
+#  U.S. Department of Energy and the U.S. Government consequently retains
+#  certain rights. As such, the U.S. Government has been granted for itself
+#  and others acting on its behalf a paid-up, nonexclusive, irrevocable,
+#  worldwide license in the Software to reproduce, distribute copies to the
+#  public, prepare derivative works, and perform publicly and display
+#  publicly, and to permit other to do so.
+#  ___________________________________________________________________________
+
+from enum import Enum
+import logging
+from scipy.sparse import coo_matrix
+
+from pyomo.common.dependencies import (
+    numpy as np,
+)
+
+from pyomo.contrib.doe import ObjectiveLib
+
+from pyomo.contrib.pynumero.interfaces.external_grey_box import ExternalGreyBoxBlock, ExternalGreyBoxModel
+
+import pyomo.environ as pyo
+
+
+class FIMExternalGreyBox(ExternalGreyBoxModel):
+    def __init__(
+            self,
+            doe_object,
+            obj_option="determinant",
+            logger_level=None,
+    ):
+        """
+        Grey box model for metrics on the FIM. This methodology reduces numerical complexity for the
+        computation of FIM metrics related to eigenvalue decomposition.
+
+        Parameters
+        ----------
+        doe_object:
+           Design of Experiments object that contains a built model (with sensitivity matrix, Q, and 
+           fisher information matrix, FIM). The external grey box model will utilize elements of the
+           doe_object's model to build the FIM metric with consistent naming. 
+        obj_option:
+           String representation of the objective option. Current available option is ``determinant``.
+           Other options that are planned to be implemented soon are ``minimum_eig`` (E-optimality), 
+           and ``condition_number`` (modified E-optimality). default option is ``determinant``
+        logger_level:
+           logging level to be specified if different from doe_object's logging level. default value
+           is None, or equivalently, use the logging level of doe_object. Use logging.DEBUG for all
+           messages.
+        """
+
+        if doe_object is None:
+            raise ValueError("DoE Object must be provided to build external grey box of the FIM.")
+
+        # Check if the doe_object has model components that are required
+        # TODO: add checks for the model --> doe_object.model needs FIM; all other checks should
+        #       have been satisfied before the FIM is created. Can add check for unknown_parameters...
+        self.obj_option = ObjectiveLib(obj_option)
+
+        # Create logger for FIM egb object
+        self.logger = logging.getLogger(__name__)
+
+        # If logger level is None, use doe_object's logger level
+        if logger_level is None:
+            logger_level = doe_object.logger.getLevel()
+
+        self.logger.setLevel(level=logger_level)
+
+    
+    def input_names(self):
+        # ToDo: add input names from the FIM coming in from
+        # Question --> Should we avoid fragility and pass model components?
+        #              Then we can grab names from the model components?
+        #              Or is the fragility user-specified strings?
+        return
+
+    def equality_constraint_names(self):
+        # ToDo: Are there any objectives that will have constraints?
+        return
+
+    def output_names(self):
+        # ToDo: add output name for the variable. This may have to be
+        # an input from the user. Or it could depend on the usage of
+        # the ObjectiveLib Enum object, which should have an associated
+        # name for the objective function at all times.
+        return
+
+    def set_input_values(self, input_values):
+        # ToDo: update this to add checks and update if necessary
+        # Assert that the names and inputs values have the same
+        # length here.
+        self._input_values = list(input_values)
+
+    def evaluate_equality_constraints(self):
+        # ToDo: are there any objectives that will have constraints?
+        return
+
+    def evaluate_outputs(self):
+        # ToDo: Take the objective function option and perform the
+        # mathematical action to get the objective.
+        return np.asarray([], dtype=np.float64)
+
+    def finalize_block_construction(self, pyomo_block):
+        # Set bounds on the inputs/outputs
+        # This will depend on the objective used
+        
+        # No return statement
+        pass
+
+    def evaluate_jacobian_equality_constraints(self):
+        # ToDo: Do any objectives require constraints?
+
+        # Returns coo_matrix of the correct shape
+        return
+        
+    def evaluate_jacobian_outputs(self):
+        # ToDo: compute the jacobian of the objective function with
+        # respect to the fisher information matrix. Then return
+        # a coo_matrix that aligns with what IPOPT will expect.
+        #
+        # ToDo: there will be significant bookkeeping for more
+        # complicated objective functions and the Hessian
+
+        # Returns coo_matrix of the correct shape
+        return
+
+    # Beyond here is for Hessian information
+    def set_equality_constraint_multipliers(self, eq_con_multiplier_values):
+        # ToDo: Do any objectives require constraints?
+        # Assert lengths match
+        self._eq_con_mult_values = np.asarray(eq_con_multiplier_values, dtype=np.float64)
+
+    def set_output_constraint_multipliers(self, output_con_multiplier_values):
+        # ToDo: Do any objectives require constraints?
+        # Assert length matches
+        self._output_con_mult_values = np.asarray(output_con_multiplier_values, dtype=np.float64)
+
+    def evaluate_hessian_equality_constraints(self):
+        # ToDo: Do any objectives require constraints?
+
+        # Returns coo_matrix of the correct shape
+        return
+
+    def evaluate_hessian_outputs(self):
+        # ToDo: Add for objectives where we can define the Hessian
+        #
+        # ToDo: significant bookkeeping if the hessian's require vectorized
+        # operations. Just need mapping that works well and we are good.
+        
+        # Returns coo_matrix of the correct shape
+        return

From abf74d4d09bf0f35cad2a9c5f0fc484d38a13e8a Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Fri, 6 Dec 2024 11:06:10 -0500
Subject: [PATCH 004/143] Added grey box utilities to init.py

---
 pyomo/contrib/doe/__init__.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pyomo/contrib/doe/__init__.py b/pyomo/contrib/doe/__init__.py
index 14589244135..4d644adac6e 100644
--- a/pyomo/contrib/doe/__init__.py
+++ b/pyomo/contrib/doe/__init__.py
@@ -10,6 +10,7 @@
 #  ___________________________________________________________________________
 from .doe import DesignOfExperiments, ObjectiveLib, FiniteDifferenceStep
 from .utils import rescale_FIM
+from .grey_box_utilities import FIMExternalGreyBox
 
 # Deprecation errors for old Pyomo.DoE interface classes and structures
 from pyomo.common.deprecation import deprecated

From b95479b80dabc14f91504d08de670f1c9bd0e30d Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Fri, 6 Dec 2024 15:26:03 -0500
Subject: [PATCH 005/143] Add log-det greybox functionality to doe

Added a single version of grey box. Currently cannot solve due to the model not being a Pyomo Block. Will revisit next week.
---
 pyomo/contrib/doe/doe.py                      |  46 +++++-
 .../doe/examples/grey_box_D_opt_comparison.py | 145 ++++++++++++++++++
 pyomo/contrib/doe/grey_box_utilities.py       |  76 ++++++---
 3 files changed, 241 insertions(+), 26 deletions(-)
 create mode 100644 pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index 5f3151961fb..959424bad14 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -45,6 +45,10 @@
 
 from pyomo.contrib.sensitivity_toolbox.sens import get_dsdp
 
+from pyomo.contrib.doe.grey_box_utilities import FIMExternalGreyBox
+
+from pyomo.contrib.pynumero.interfaces.external_grey_box import ExternalGreyBoxBlock
+
 import pyomo.environ as pyo
 
 from pyomo.opt import SolverStatus
@@ -70,6 +74,7 @@ def __init__(
         fd_formula="central",
         step=1e-3,
         objective_option="determinant",
+        use_grey_box_objective=False,
         scale_constant_value=1.0,
         scale_nominal_param_value=False,
         prior_FIM=None,
@@ -106,6 +111,9 @@ def __init__(
             String representation of the objective option. Current available options are:
             ``determinant`` (for determinant, or D-optimality) and ``trace`` (for trace or
             A-optimality)
+        use_grey_box_objective:
+            Boolean of whether or not to use the grey-box version of the objective function.
+            True to use grey box, False to use standard. Default: False (do not use grey box)
         scale_constant_value:
             Constant scaling for the sensitivity matrix. Every element will be multiplied by this
             scaling factor.
@@ -164,6 +172,7 @@ def __init__(
 
         # Set the objective type and scaling options:
         self.objective_option = ObjectiveLib(objective_option)
+        self.use_grey_box = use_grey_box_objective
 
         self.scale_constant_value = scale_constant_value
         self.scale_nominal_param_value = scale_nominal_param_value
@@ -191,6 +200,13 @@ def __init__(
 
         self.tee = tee
 
+        # ToDo: allow user to supply grey box solver
+        if self.use_grey_box:
+            solver = pyo.SolverFactory("cyipopt")
+            solver.config.options['hessian_approximation'] = 'limited-memory'
+
+            self.solver = solver
+
         # Set get_labeled_model_args as an empty dict if no arguments are passed
         if get_labeled_model_args is None:
             get_labeled_model_args = {}
@@ -256,7 +272,35 @@ def run_doe(self, model=None, results_file=None):
             self.create_doe_model(model=model)
 
         # Add the objective function to the model
-        self.create_objective_function(model=model)
+        if self.use_grey_box:
+            # Add external grey box block to a block named ``obj_cons`` to
+            # resuse material for initializing the objective-free square model
+            # ToDo: Make this naming convention robust
+            model.obj_cons = pyo.Block()
+            # ToDo: Add functionality for grey box objectives
+            grey_box_FIM = FIMExternalGreyBox(doe_object=self, objective_option=self.objective_option, logger_level=self.logger.getEffectiveLevel())
+            model.obj_cons.egb_fim_block = ExternalGreyBoxBlock(external_model=grey_box_FIM)
+
+            # Adding constraints to for all grey box input values to equate to fim values
+            def FIM_egb_cons(m, p1, p2):
+                """
+                
+                m: Pyomo model
+                p1: parameter 1
+                p2: parameter 2
+                
+                """
+                return model.fim[(p1, p2)] == m.egb_fim_block.inputs[(p1, p2)]
+            model.obj_cons.FIM_equalities = pyo.Constraint(model.parameter_names, model.parameter_names, rule=FIM_egb_cons)
+            model.obj_cons.pprint()
+
+            # ToDo: Add naming convention to adjust name of objective output
+            # to conincide with the ObjectiveLib type
+            # Proposal --> Use alphabetic opt e.g., ``A-opt``, ``D-opt``, etc.
+            # Add objective function from FIM grey box calculation
+            model.objective = pyo.Objective(expr=model.obj_cons.egb_fim_block.outputs["log_det"])  # Must change hardcoding
+        else:
+            self.create_objective_function(model=model)
 
         # Track time required to build the DoE model
         build_time = sp_timer.toc(msg=None)
diff --git a/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py b/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
new file mode 100644
index 00000000000..71ea6fb3bac
--- /dev/null
+++ b/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
@@ -0,0 +1,145 @@
+#  ___________________________________________________________________________
+#
+#  Pyomo: Python Optimization Modeling Objects
+#  Copyright (c) 2008-2024
+#  National Technology and Engineering Solutions of Sandia, LLC
+#  Under the terms of Contract DE-NA0003525 with National Technology and
+#  Engineering Solutions of Sandia, LLC, the U.S. Government retains certain
+#  rights in this software.
+#  This software is distributed under the 3-clause BSD License.
+#  ___________________________________________________________________________
+from pyomo.common.dependencies import numpy as np
+
+from pyomo.contrib.doe.examples.reactor_experiment import ReactorExperiment
+from pyomo.contrib.doe import DesignOfExperiments
+
+import pyomo.environ as pyo
+
+import json
+from pathlib import Path
+
+
+# Seeing if D-optimal experiment matches for both the
+# greybox objective and the algebraic objective
+def compare_reactor_doe():
+    # Read in file
+    DATA_DIR = Path(__file__).parent
+    file_path = DATA_DIR / "result.json"
+
+    with open(file_path) as f:
+        data_ex = json.load(f)
+
+    # Put temperature control time points into correct format for reactor experiment
+    data_ex["control_points"] = {
+        float(k): v for k, v in data_ex["control_points"].items()
+    }
+
+    # Create a ReactorExperiment object; data and discretization information are part
+    # of the constructor of this object
+    experiment = ReactorExperiment(data=data_ex, nfe=10, ncp=3)
+
+    # Use a central difference, with step size 1e-3
+    fd_formula = "central"
+    step_size = 1e-3
+
+    # Use the determinant objective with scaled sensitivity matrix
+    objective_option = "determinant"
+    scale_nominal_param_value = True
+
+    solver = pyo.SolverFactory("ipopt")
+    solver.options["linear_solver"] = "mumps"
+    # Create the DesignOfExperiments object
+    # We will not be passing any prior information in this example
+    # and allow the experiment object and the DesignOfExperiments
+    # call of ``run_doe`` perform model initialization.
+    doe_obj = DesignOfExperiments(
+        experiment,
+        fd_formula=fd_formula,
+        step=step_size,
+        objective_option=objective_option,
+        scale_constant_value=1,
+        scale_nominal_param_value=scale_nominal_param_value,
+        prior_FIM=None,
+        jac_initial=None,
+        fim_initial=None,
+        L_diagonal_lower_bound=1e-7,
+        solver=solver,
+        tee=True,
+        get_labeled_model_args=None,
+        _Cholesky_option=True,
+        _only_compute_fim_lower=True,
+    )
+
+    # Begin optimal DoE
+    ####################
+    doe_obj.run_doe()
+
+    # Print out a results summary
+    print("Optimal experiment values: ")
+    print(
+        "\tInitial concentration: {:.2f}".format(
+            doe_obj.results["Experiment Design"][0]
+        )
+    )
+    print(
+        ("\tTemperature values: [" + "{:.2f}, " * 8 + "{:.2f}]").format(
+            *doe_obj.results["Experiment Design"][1:]
+        )
+    )
+    print("FIM at optimal design:\n {}".format(np.array(doe_obj.results["FIM"])))
+    print(
+        "Objective value at optimal design: {:.2f}".format(
+            pyo.value(doe_obj.model.objective)
+        )
+    )
+
+    print(doe_obj.results["Experiment Design Names"])
+
+    ###################
+    # End optimal DoE
+
+    # Begin optimal grey box DoE
+    ############################
+    doe_obj_grey_box = DesignOfExperiments(
+        experiment,
+        fd_formula=fd_formula,
+        step=step_size,
+        objective_option=objective_option,
+        use_grey_box_objective=True,  # New object with grey box set to True
+        scale_constant_value=1,
+        scale_nominal_param_value=scale_nominal_param_value,
+        prior_FIM=None,
+        jac_initial=None,
+        fim_initial=None,
+        L_diagonal_lower_bound=1e-7,
+        solver=solver,
+        tee=False,
+        get_labeled_model_args=None,
+        _Cholesky_option=True,
+        _only_compute_fim_lower=True,
+    )
+
+    doe_obj_grey_box.run_doe()
+    # Print out a results summary                                                                                                                      
+    print("Optimal experiment values: ")
+    print(
+        "\tInitial concentration: {:.2f}".format(
+            doe_obj.results["Experiment Design"][0]
+        )
+    )
+    print(
+        ("\tTemperature values: [" + "{:.2f}, " * 8 + "{:.2f}]").format(
+            *doe_obj.results["Experiment Design"][1:]
+        )
+    )
+    print("FIM at optimal design:\n {}".format(np.array(doe_obj.results["FIM"])))
+    print(
+        "Objective value at optimal design: {:.2f}".format(
+            pyo.value(doe_obj.model.objective)
+        )
+    )
+
+    print(doe_obj.results["Experiment Design Names"])
+
+if __name__ == "__main__":
+    compare_reactor_doe()
diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index c17ec5ebbf2..5db99828889 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -26,6 +26,7 @@
 #  ___________________________________________________________________________
 
 from enum import Enum
+import itertools
 import logging
 from scipy.sparse import coo_matrix
 
@@ -33,9 +34,7 @@
     numpy as np,
 )
 
-from pyomo.contrib.doe import ObjectiveLib
-
-from pyomo.contrib.pynumero.interfaces.external_grey_box import ExternalGreyBoxBlock, ExternalGreyBoxModel
+from pyomo.contrib.pynumero.interfaces.external_grey_box import ExternalGreyBoxModel
 
 import pyomo.environ as pyo
 
@@ -44,7 +43,7 @@ class FIMExternalGreyBox(ExternalGreyBoxModel):
     def __init__(
             self,
             doe_object,
-            obj_option="determinant",
+            objective_option="determinant",
             logger_level=None,
     ):
         """
@@ -70,10 +69,16 @@ def __init__(
         if doe_object is None:
             raise ValueError("DoE Object must be provided to build external grey box of the FIM.")
 
+        self.doe_object = doe_object
+
+        # Grab parameter list from the doe_object model
+        self._param_names = [i for i in self.doe_object.model.parameter_names]
+        
         # Check if the doe_object has model components that are required
         # TODO: add checks for the model --> doe_object.model needs FIM; all other checks should
         #       have been satisfied before the FIM is created. Can add check for unknown_parameters...
-        self.obj_option = ObjectiveLib(obj_option)
+        self.objective_option = objective_option.name  # Add failsafe to make sure this is ObjectiveLib object?
+        # Will anyone ever call this without calling DoE? --> intended to be no; but maybe more utility?
 
         # Create logger for FIM egb object
         self.logger = logging.getLogger(__name__)
@@ -86,50 +91,58 @@ def __init__(
 
     
     def input_names(self):
-        # ToDo: add input names from the FIM coming in from
-        # Question --> Should we avoid fragility and pass model components?
-        #              Then we can grab names from the model components?
-        #              Or is the fragility user-specified strings?
-        return
+        # Cartesian product gives us matrix indicies flattened in row-first format
+        input_names_list = list(itertools.product(self._param_names, self._param_names))
+        return input_names_list
 
     def equality_constraint_names(self):
         # ToDo: Are there any objectives that will have constraints?
-        return
+        return []
 
     def output_names(self):
         # ToDo: add output name for the variable. This may have to be
         # an input from the user. Or it could depend on the usage of
         # the ObjectiveLib Enum object, which should have an associated
         # name for the objective function at all times.
-        return
+        return ["log_det", ]  # Change for hard-coded D-optimality
 
     def set_input_values(self, input_values):
-        # ToDo: update this to add checks and update if necessary
-        # Assert that the names and inputs values have the same
-        # length here.
-        self._input_values = list(input_values)
+        # Set initial values to be flattened initial FIM (aligns with input names)
+        self._input_values = list(self.doe_object.fim_initial.flatten())
 
     def evaluate_equality_constraints(self):
         # ToDo: are there any objectives that will have constraints?
-        return
+        return None
 
     def evaluate_outputs(self):
         # ToDo: Take the objective function option and perform the
         # mathematical action to get the objective.
-        return np.asarray([], dtype=np.float64)
+
+        # CALCULATE THE INVERSE VALUE
+        # CHANGE HARD-CODED LOG DET
+        M = np.asarray(self._input_values, dtype=np.float64).reshape(len(self._param_names), len(self._param_names))
+
+        (sign, logdet) = np.linalg.slogdet(M)
+        
+        return np.asarray([logdet, ], dtype=np.float64)
 
     def finalize_block_construction(self, pyomo_block):
         # Set bounds on the inputs/outputs
+        # Set initial values of the inputs/outputs
         # This will depend on the objective used
-        
-        # No return statement
-        pass
+
+        # Initialize grey box FIM values
+        for ind, val in enumerate(self.input_names()):
+            pyomo_block.inputs[val] = self.doe_object.fim_initial.flatten()[ind]
+
+        # Initialize log_determinant value
+        pyomo_block.outputs["log_det"] = 0  # Remember to change hardcoded name
 
     def evaluate_jacobian_equality_constraints(self):
         # ToDo: Do any objectives require constraints?
 
         # Returns coo_matrix of the correct shape
-        return
+        return None
         
     def evaluate_jacobian_outputs(self):
         # ToDo: compute the jacobian of the objective function with
@@ -138,9 +151,22 @@ def evaluate_jacobian_outputs(self):
         #
         # ToDo: there will be significant bookkeeping for more
         # complicated objective functions and the Hessian
+        M = np.asarray(self._input_values, dtype=np.float64).reshape(len(self._param_names), len(self._param_names))
+        
+        Minv = np.linalg.pinv(M)
+
+        # Since M is symmetric, the derivative of logdet(M) w.r.t M is
+        # 2*inverse(M) - diagonal(inverse(M)) ADD SOURCE
+        jac_M = 2*Minv - np.diagonal(Minv)
+
+        # Rows are the integer division by number of columns
+        M_rows = np.arange(len(jac_M.flatten())) // jac_M.shape[1]
+
+        # Columns are the remaindar (mod) by number of rows
+        M_cols = np.arange(len(jac_M.flatten())) % jac_M.shape[0]
 
         # Returns coo_matrix of the correct shape
-        return
+        return coo_matrix((jac_M.flatten(), (M_rows, M_cols)), shape=jac_M.shape())
 
     # Beyond here is for Hessian information
     def set_equality_constraint_multipliers(self, eq_con_multiplier_values):
@@ -157,7 +183,7 @@ def evaluate_hessian_equality_constraints(self):
         # ToDo: Do any objectives require constraints?
 
         # Returns coo_matrix of the correct shape
-        return
+        return None
 
     def evaluate_hessian_outputs(self):
         # ToDo: Add for objectives where we can define the Hessian
@@ -166,4 +192,4 @@ def evaluate_hessian_outputs(self):
         # operations. Just need mapping that works well and we are good.
         
         # Returns coo_matrix of the correct shape
-        return
+        return None

From ea6831b43db89ae440a9debfe842800d5523c0ec Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Tue, 10 Dec 2024 15:48:20 -0500
Subject: [PATCH 006/143] Update to call greybox solver

Added greybox solver separate from regular solver (will call normal ipopt to solve subproblems without grey box model). Fixed bugs with grey box utilities to now update the input values correctly.

Having determinism issue.
---
 pyomo/contrib/doe/doe.py                      | 28 ++++++++++------
 .../doe/examples/grey_box_D_opt_comparison.py | 30 +++++++++++++++--
 pyomo/contrib/doe/grey_box_utilities.py       | 33 +++++++++++++------
 3 files changed, 69 insertions(+), 22 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index 959424bad14..1739dbf9c35 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -82,6 +82,7 @@ def __init__(
         fim_initial=None,
         L_diagonal_lower_bound=1e-7,
         solver=None,
+        grey_box_solver=None,
         tee=False,
         get_labeled_model_args=None,
         logger_level=logging.WARNING,
@@ -193,7 +194,8 @@ def __init__(
         # if not given, use default solver
         else:
             solver = pyo.SolverFactory("ipopt")
-            solver.options["linear_solver"] = "ma57"
+            # solver.options["linear_solver"] = "ma57"
+            solver.options["linear_solver"] = "MUMPS"
             solver.options["halt_on_ampl_error"] = "yes"
             solver.options["max_iter"] = 3000
             self.solver = solver
@@ -201,11 +203,15 @@ def __init__(
         self.tee = tee
 
         # ToDo: allow user to supply grey box solver
-        if self.use_grey_box:
-            solver = pyo.SolverFactory("cyipopt")
-            solver.config.options['hessian_approximation'] = 'limited-memory'
+        if grey_box_solver:
+            self.grey_box_solver = grey_box_solver
+        else:
+            grey_box_solver = pyo.SolverFactory("cyipopt")
+            grey_box_solver.config.options['hessian_approximation'] = 'limited-memory'
+            grey_box_solver.config.options['max_iter'] = 3000
+            grey_box_solver.config.options['mu_strategy'] = "monotone"
 
-            self.solver = solver
+            self.grey_box_solver = grey_box_solver
 
         # Set get_labeled_model_args as an empty dict if no arguments are passed
         if get_labeled_model_args is None:
@@ -292,13 +298,12 @@ def FIM_egb_cons(m, p1, p2):
                 """
                 return model.fim[(p1, p2)] == m.egb_fim_block.inputs[(p1, p2)]
             model.obj_cons.FIM_equalities = pyo.Constraint(model.parameter_names, model.parameter_names, rule=FIM_egb_cons)
-            model.obj_cons.pprint()
-
+            
             # ToDo: Add naming convention to adjust name of objective output
             # to conincide with the ObjectiveLib type
             # Proposal --> Use alphabetic opt e.g., ``A-opt``, ``D-opt``, etc.
             # Add objective function from FIM grey box calculation
-            model.objective = pyo.Objective(expr=model.obj_cons.egb_fim_block.outputs["log_det"])  # Must change hardcoding
+            model.objective = pyo.Objective(expr=model.obj_cons.egb_fim_block.outputs["log_det"], sense=pyo.maximize)  # Must change hardcoding
         else:
             self.create_objective_function(model=model)
 
@@ -362,7 +367,10 @@ def FIM_egb_cons(m, p1, p2):
             model.determinant.value = np.linalg.det(np.array(self.get_FIM()))
 
         # Solve the full model, which has now been initialized with the square solve
-        res = self.solver.solve(model, tee=self.tee)
+        if self.use_grey_box:
+            res = self.grey_box_solver.solve(model, tee=self.tee)
+        else:
+            res = self.solver.solve(model, tee=self.tee)
 
         # Track time used to solve the DoE model
         solve_time = sp_timer.toc(msg=None)
@@ -375,7 +383,7 @@ def FIM_egb_cons(m, p1, p2):
             % (build_time + initialization_time + solve_time)
         )
 
-        #
+        # Avoid accidental carry-over of FIM information
         fim_local = self.get_FIM()
 
         # Make sure stale results don't follow the DoE object instance
diff --git a/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py b/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
index 71ea6fb3bac..95f6e8adf19 100644
--- a/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
+++ b/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
@@ -16,6 +16,7 @@
 import pyomo.environ as pyo
 
 import json
+import logging
 from pathlib import Path
 
 
@@ -64,8 +65,9 @@ def compare_reactor_doe():
         fim_initial=None,
         L_diagonal_lower_bound=1e-7,
         solver=solver,
-        tee=True,
+        tee=False,
         get_labeled_model_args=None,
+        #logger_level=logging.ERROR,
         _Cholesky_option=True,
         _only_compute_fim_lower=True,
     )
@@ -113,8 +115,9 @@ def compare_reactor_doe():
         fim_initial=None,
         L_diagonal_lower_bound=1e-7,
         solver=solver,
-        tee=False,
+        tee=True,
         get_labeled_model_args=None,
+        #logger_level=logging.ERROR,
         _Cholesky_option=True,
         _only_compute_fim_lower=True,
     )
@@ -122,6 +125,28 @@ def compare_reactor_doe():
     doe_obj_grey_box.run_doe()
     # Print out a results summary                                                                                                                      
     print("Optimal experiment values: ")
+    print(
+        "\tInitial concentration: {:.2f}".format(
+            doe_obj_grey_box.results["Experiment Design"][0]
+        )
+    )
+    print(
+        ("\tTemperature values: [" + "{:.2f}, " * 8 + "{:.2f}]").format(
+            *doe_obj_grey_box.results["Experiment Design"][1:]
+        )
+    )
+    print("FIM at optimal design:\n {}".format(np.array(doe_obj_grey_box.results["FIM"])))
+    print(
+        "Objective value at optimal design: {:.2f}".format(
+            pyo.value(doe_obj_grey_box.model.objective)
+        )
+    )
+    print("Raw logdet: {:.2f}".format(np.log10(np.linalg.det(np.array(doe_obj_grey_box.results["FIM"])))))
+
+    print(doe_obj_grey_box.results["Experiment Design Names"])
+
+    # Print out a results summary
+    print("Optimal experiment values: ")
     print(
         "\tInitial concentration: {:.2f}".format(
             doe_obj.results["Experiment Design"][0]
@@ -141,5 +166,6 @@ def compare_reactor_doe():
 
     print(doe_obj.results["Experiment Design Names"])
 
+    
 if __name__ == "__main__":
     compare_reactor_doe()
diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index 5db99828889..abc56ded048 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -89,6 +89,9 @@ def __init__(
 
         self.logger.setLevel(level=logger_level)
 
+        # Set initial values for inputs
+        self._input_values = np.asarray(self.doe_object.fim_initial.flatten(), dtype=np.float64)
+
     
     def input_names(self):
         # Cartesian product gives us matrix indicies flattened in row-first format
@@ -108,7 +111,8 @@ def output_names(self):
 
     def set_input_values(self, input_values):
         # Set initial values to be flattened initial FIM (aligns with input names)
-        self._input_values = list(self.doe_object.fim_initial.flatten())
+        np.copyto(self._input_values, input_values)
+        #self._input_values = list(self.doe_object.fim_initial.flatten())
 
     def evaluate_equality_constraints(self):
         # ToDo: are there any objectives that will have constraints?
@@ -120,8 +124,9 @@ def evaluate_outputs(self):
 
         # CALCULATE THE INVERSE VALUE
         # CHANGE HARD-CODED LOG DET
-        M = np.asarray(self._input_values, dtype=np.float64).reshape(len(self._param_names), len(self._param_names))
-
+        current_FIM = self._input_values
+        M = np.asarray(current_FIM, dtype=np.float64).reshape(len(self._param_names), len(self._param_names))
+        
         (sign, logdet) = np.linalg.slogdet(M)
         
         return np.asarray([logdet, ], dtype=np.float64)
@@ -150,8 +155,9 @@ def evaluate_jacobian_outputs(self):
         # a coo_matrix that aligns with what IPOPT will expect.
         #
         # ToDo: there will be significant bookkeeping for more
-        # complicated objective functions and the Hessian
-        M = np.asarray(self._input_values, dtype=np.float64).reshape(len(self._param_names), len(self._param_names))
+        # complicated objective functions and the Hessian        
+        current_FIM = self._input_values
+        M = np.asarray(current_FIM, dtype=np.float64).reshape(len(self._param_names), len(self._param_names))
         
         Minv = np.linalg.pinv(M)
 
@@ -165,8 +171,15 @@ def evaluate_jacobian_outputs(self):
         # Columns are the remaindar (mod) by number of rows
         M_cols = np.arange(len(jac_M.flatten())) % jac_M.shape[0]
 
+        # Need to be flat?
+        M_rows = np.zeros((len(jac_M.flatten()), 1)).flatten()
+
+        # Need to be flat?
+        M_cols = np.arange(len(jac_M.flatten()))
+        
         # Returns coo_matrix of the correct shape
-        return coo_matrix((jac_M.flatten(), (M_rows, M_cols)), shape=jac_M.shape())
+        #print(coo_matrix((jac_M.flatten(), (M_rows, M_cols)), shape=(1, len(jac_M.flatten()))))
+        return coo_matrix((jac_M.flatten(), (M_rows, M_cols)), shape=(1, len(jac_M.flatten())))
 
     # Beyond here is for Hessian information
     def set_equality_constraint_multipliers(self, eq_con_multiplier_values):
@@ -179,17 +192,17 @@ def set_output_constraint_multipliers(self, output_con_multiplier_values):
         # Assert length matches
         self._output_con_mult_values = np.asarray(output_con_multiplier_values, dtype=np.float64)
 
-    def evaluate_hessian_equality_constraints(self):
+#    def evaluate_hessian_equality_constraints(self):
         # ToDo: Do any objectives require constraints?
 
         # Returns coo_matrix of the correct shape
-        return None
+#        return None
 
-    def evaluate_hessian_outputs(self):
+#    def evaluate_hessian_outputs(self):
         # ToDo: Add for objectives where we can define the Hessian
         #
         # ToDo: significant bookkeeping if the hessian's require vectorized
         # operations. Just need mapping that works well and we are good.
         
         # Returns coo_matrix of the correct shape
-        return None
+#        return None

From 2483217489d3e0df2c90da292e6a1ca3f4b88397 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 12 Dec 2024 13:29:58 -0500
Subject: [PATCH 007/143] Testing math to make sure formula is correct

---
 pyomo/contrib/doe/doe.py                      | 19 ++++++++++++++++++-
 .../doe/examples/grey_box_D_opt_comparison.py |  2 +-
 pyomo/contrib/doe/grey_box_utilities.py       | 11 +++++++++++
 3 files changed, 30 insertions(+), 2 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index 1739dbf9c35..aabeef8d81a 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -209,7 +209,7 @@ def __init__(
             grey_box_solver = pyo.SolverFactory("cyipopt")
             grey_box_solver.config.options['hessian_approximation'] = 'limited-memory'
             grey_box_solver.config.options['max_iter'] = 3000
-            grey_box_solver.config.options['mu_strategy'] = "monotone"
+            # grey_box_solver.config.options['mu_strategy'] = "monotone"
 
             self.grey_box_solver = grey_box_solver
 
@@ -297,6 +297,10 @@ def FIM_egb_cons(m, p1, p2):
                 
                 """
                 return model.fim[(p1, p2)] == m.egb_fim_block.inputs[(p1, p2)]
+                #if list(model.parameter_names).index(p1) >= list(model.parameter_names).index(p2):
+                #    return model.fim[(p1, p2)] == m.egb_fim_block.inputs[(p1, p2)]
+                #else:
+                #    return pyo.Constraint.Skip
             model.obj_cons.FIM_equalities = pyo.Constraint(model.parameter_names, model.parameter_names, rule=FIM_egb_cons)
             
             # ToDo: Add naming convention to adjust name of objective output
@@ -346,6 +350,12 @@ def FIM_egb_cons(m, p1, p2):
         model.objective.activate()
         model.obj_cons.activate()
 
+        if self.use_grey_box:
+            # Initialize grey box inputs to be fim values currently
+            for i in model.parameter_names:
+                for j in model.parameter_names:
+                    model.obj_cons.egb_fim_block.inputs[(i, j)].set_value(pyo.value(model.fim[(i, j)]))
+        
         # If the model has L, initialize it with the solved FIM
         if hasattr(model, "L"):
             # Get the FIM values
@@ -368,6 +378,13 @@ def FIM_egb_cons(m, p1, p2):
 
         # Solve the full model, which has now been initialized with the square solve
         if self.use_grey_box:
+            #from idaes.core.util.model_diagnostics import DiagnosticsToolbox
+            #dt = DiagnosticsToolbox(model, constraint_residual_tolerance=1e-10)
+            self.grey_box_solver.config.options['tol'] = 1e-3
+            res = self.grey_box_solver.solve(model, tee=self.tee)
+            # Doing diagnostics
+            #dt.display_constraints_with_large_residuals()
+            self.grey_box_solver.config.options['tol'] = 1e-6
             res = self.grey_box_solver.solve(model, tee=self.tee)
         else:
             res = self.solver.solve(model, tee=self.tee)
diff --git a/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py b/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
index 95f6e8adf19..7559e710f71 100644
--- a/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
+++ b/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
@@ -65,7 +65,7 @@ def compare_reactor_doe():
         fim_initial=None,
         L_diagonal_lower_bound=1e-7,
         solver=solver,
-        tee=False,
+        tee=True,
         get_labeled_model_args=None,
         #logger_level=logging.ERROR,
         _Cholesky_option=True,
diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index abc56ded048..849120e2886 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -126,6 +126,10 @@ def evaluate_outputs(self):
         # CHANGE HARD-CODED LOG DET
         current_FIM = self._input_values
         M = np.asarray(current_FIM, dtype=np.float64).reshape(len(self._param_names), len(self._param_names))
+
+        # Trying symmetry calculation?
+        #M = np.multiply(M, np.tril(np.ones((len(self._param_names), len(self._param_names)))))
+        #M = M + M.transpose() - np.multiply(M, np.eye(len(self._param_names)))
         
         (sign, logdet) = np.linalg.slogdet(M)
         
@@ -158,8 +162,15 @@ def evaluate_jacobian_outputs(self):
         # complicated objective functions and the Hessian        
         current_FIM = self._input_values
         M = np.asarray(current_FIM, dtype=np.float64).reshape(len(self._param_names), len(self._param_names))
+
+        # Trying symmetry calculation?
+        #M = np.multiply(M, np.tril(np.ones((len(self._param_names), len(self._param_names)))))
+        #M = M + M.transpose() - np.multiply(M, np.eye(len(self._param_names)))
         
         Minv = np.linalg.pinv(M)
+        eig, _ = np.linalg.eig(M)
+        if min(eig) <= 1:
+            print("Warning: {:0.6f}".format(min(eig)))
 
         # Since M is symmetric, the derivative of logdet(M) w.r.t M is
         # 2*inverse(M) - diagonal(inverse(M)) ADD SOURCE

From b90f9089afc40b0cd1ba23102dfacd4c878eabaa Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Wed, 18 Dec 2024 08:36:05 -0500
Subject: [PATCH 008/143] Updates for debugging

---
 pyomo/contrib/doe/doe.py                | 20 ++++++--------------
 pyomo/contrib/doe/grey_box_utilities.py | 15 ++++++++++++++-
 2 files changed, 20 insertions(+), 15 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index aabeef8d81a..5c5b26382e2 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -194,7 +194,7 @@ def __init__(
         # if not given, use default solver
         else:
             solver = pyo.SolverFactory("ipopt")
-            # solver.options["linear_solver"] = "ma57"
+            #solver.options["linear_solver"] = "ma57"
             solver.options["linear_solver"] = "MUMPS"
             solver.options["halt_on_ampl_error"] = "yes"
             solver.options["max_iter"] = 3000
@@ -209,7 +209,7 @@ def __init__(
             grey_box_solver = pyo.SolverFactory("cyipopt")
             grey_box_solver.config.options['hessian_approximation'] = 'limited-memory'
             grey_box_solver.config.options['max_iter'] = 3000
-            # grey_box_solver.config.options['mu_strategy'] = "monotone"
+            grey_box_solver.config.options['mu_strategy'] = "monotone"
 
             self.grey_box_solver = grey_box_solver
 
@@ -296,11 +296,10 @@ def FIM_egb_cons(m, p1, p2):
                 p2: parameter 2
                 
                 """
-                return model.fim[(p1, p2)] == m.egb_fim_block.inputs[(p1, p2)]
-                #if list(model.parameter_names).index(p1) >= list(model.parameter_names).index(p2):
-                #    return model.fim[(p1, p2)] == m.egb_fim_block.inputs[(p1, p2)]
-                #else:
-                #    return pyo.Constraint.Skip
+                if list(model.parameter_names).index(p1) >= list(model.parameter_names).index(p2):
+                    return model.fim[(p1, p2)] == m.egb_fim_block.inputs[(p1, p2)]
+                else:
+                    return model.fim[(p2, p1)] == m.egb_fim_block.inputs[(p1, p2)]
             model.obj_cons.FIM_equalities = pyo.Constraint(model.parameter_names, model.parameter_names, rule=FIM_egb_cons)
             
             # ToDo: Add naming convention to adjust name of objective output
@@ -378,13 +377,6 @@ def FIM_egb_cons(m, p1, p2):
 
         # Solve the full model, which has now been initialized with the square solve
         if self.use_grey_box:
-            #from idaes.core.util.model_diagnostics import DiagnosticsToolbox
-            #dt = DiagnosticsToolbox(model, constraint_residual_tolerance=1e-10)
-            self.grey_box_solver.config.options['tol'] = 1e-3
-            res = self.grey_box_solver.solve(model, tee=self.tee)
-            # Doing diagnostics
-            #dt.display_constraints_with_large_residuals()
-            self.grey_box_solver.config.options['tol'] = 1e-6
             res = self.grey_box_solver.solve(model, tee=self.tee)
         else:
             res = self.solver.solve(model, tee=self.tee)
diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index 849120e2886..24cb4b36386 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -91,6 +91,7 @@ def __init__(
 
         # Set initial values for inputs
         self._input_values = np.asarray(self.doe_object.fim_initial.flatten(), dtype=np.float64)
+        print(self._input_values)
 
     
     def input_names(self):
@@ -174,7 +175,19 @@ def evaluate_jacobian_outputs(self):
 
         # Since M is symmetric, the derivative of logdet(M) w.r.t M is
         # 2*inverse(M) - diagonal(inverse(M)) ADD SOURCE
-        jac_M = 2*Minv - np.diagonal(Minv)
+        #jac_M = 2*Minv - np.diagonal(Minv)
+        #jac_M = Minv
+
+        jac_M = 0.5*(Minv + Minv.transpose())
+
+        #print("M")
+        #print(M)
+        #print("Jac_M")
+        #print(jac_M)
+        #print("Eigenvalues")
+        #print(eig)
+        #print("Eigenvectors")
+        #print(_)
 
         # Rows are the integer division by number of columns
         M_rows = np.arange(len(jac_M.flatten())) // jac_M.shape[1]

From bedb89a9ec6efdbcc71f6b8651cd365a4e55ccc9 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Wed, 18 Dec 2024 09:56:44 -0500
Subject: [PATCH 009/143] Switch to ma57

---
 pyomo/contrib/doe/doe.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index 5c5b26382e2..0537f69e6b2 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -194,10 +194,11 @@ def __init__(
         # if not given, use default solver
         else:
             solver = pyo.SolverFactory("ipopt")
-            #solver.options["linear_solver"] = "ma57"
-            solver.options["linear_solver"] = "MUMPS"
+            solver.options["linear_solver"] = "ma57"
+            #solver.options["linear_solver"] = "MUMPS"
             solver.options["halt_on_ampl_error"] = "yes"
             solver.options["max_iter"] = 3000
+            solver.options["tol"] = 1e-4
             self.solver = solver
 
         self.tee = tee
@@ -208,7 +209,9 @@ def __init__(
         else:
             grey_box_solver = pyo.SolverFactory("cyipopt")
             grey_box_solver.config.options['hessian_approximation'] = 'limited-memory'
+            grey_box_solver.config.options["linear_solver"] = "ma57" 
             grey_box_solver.config.options['max_iter'] = 3000
+            grey_box_solver.config.options['tol'] = 1e-4
             grey_box_solver.config.options['mu_strategy'] = "monotone"
 
             self.grey_box_solver = grey_box_solver

From 8486af89abdb1cb65f5873f8f1adcc5dc65eaa51 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Wed, 18 Dec 2024 16:09:51 -0500
Subject: [PATCH 010/143] Remove tolerance changes

---
 pyomo/contrib/doe/doe.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index 0537f69e6b2..e571f807f6c 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -198,7 +198,7 @@ def __init__(
             #solver.options["linear_solver"] = "MUMPS"
             solver.options["halt_on_ampl_error"] = "yes"
             solver.options["max_iter"] = 3000
-            solver.options["tol"] = 1e-4
+            #solver.options["tol"] = 1e-4
             self.solver = solver
 
         self.tee = tee
@@ -211,7 +211,7 @@ def __init__(
             grey_box_solver.config.options['hessian_approximation'] = 'limited-memory'
             grey_box_solver.config.options["linear_solver"] = "ma57" 
             grey_box_solver.config.options['max_iter'] = 3000
-            grey_box_solver.config.options['tol'] = 1e-4
+            #grey_box_solver.config.options['tol'] = 1e-4
             grey_box_solver.config.options['mu_strategy'] = "monotone"
 
             self.grey_box_solver = grey_box_solver

From e49ffed2728565d0e8b5fbaaf63162ebecfbdd7b Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Wed, 15 Jan 2025 13:22:34 -0500
Subject: [PATCH 011/143] Fixed square solving bug while building scenarios

---
 pyomo/contrib/doe/doe.py | 21 +++++++++++++++------
 1 file changed, 15 insertions(+), 6 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index e571f807f6c..0960b5cce14 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -194,11 +194,11 @@ def __init__(
         # if not given, use default solver
         else:
             solver = pyo.SolverFactory("ipopt")
-            solver.options["linear_solver"] = "ma57"
-            #solver.options["linear_solver"] = "MUMPS"
+            #solver.options["linear_solver"] = "ma57"
+            solver.options["linear_solver"] = "MUMPS"
             solver.options["halt_on_ampl_error"] = "yes"
             solver.options["max_iter"] = 3000
-            #solver.options["tol"] = 1e-4
+            solver.options["tol"] = 1e-4
             self.solver = solver
 
         self.tee = tee
@@ -209,10 +209,10 @@ def __init__(
         else:
             grey_box_solver = pyo.SolverFactory("cyipopt")
             grey_box_solver.config.options['hessian_approximation'] = 'limited-memory'
-            grey_box_solver.config.options["linear_solver"] = "ma57" 
+            #grey_box_solver.config.options["linear_solver"] = "ma57" 
             grey_box_solver.config.options['max_iter'] = 3000
-            #grey_box_solver.config.options['tol'] = 1e-4
-            grey_box_solver.config.options['mu_strategy'] = "monotone"
+            grey_box_solver.config.options['tol'] = 1e-4
+            #grey_box_solver.config.options['mu_strategy'] = "monotone"
 
             self.grey_box_solver = grey_box_solver
 
@@ -1144,8 +1144,17 @@ def build_block_scenarios(b, s):
             pyo.ComponentUID(param, context=m.base_model).find_component_on(
                 b
             ).set_value(m.base_model.unknown_parameters[param] * (1 + diff))
+
+            # Fix experiment inputs before solve (enforce square solve)
+            for comp in b.experiment_inputs:
+                comp.fix()
+                
             res = self.solver.solve(b, tee=self.tee)
 
+            # Unfix experiment inputs after square solve
+            for comp in b.experiment_inputs:
+                comp.unfix()
+
         model.scenario_blocks = pyo.Block(model.scenarios, rule=build_block_scenarios)
 
         # To-Do: this might have to change if experiment inputs have

From d3adc4d20215f8d5dfd12fc825738203268aaba4 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 13 Mar 2025 08:25:24 -0400
Subject: [PATCH 012/143] improve output stats on D-opt test

---
 pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py b/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
index 7559e710f71..8e7018863a5 100644
--- a/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
+++ b/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
@@ -124,7 +124,7 @@ def compare_reactor_doe():
 
     doe_obj_grey_box.run_doe()
     # Print out a results summary                                                                                                                      
-    print("Optimal experiment values: ")
+    print("Optimal experiment values with grey-box: ")
     print(
         "\tInitial concentration: {:.2f}".format(
             doe_obj_grey_box.results["Experiment Design"][0]
@@ -135,9 +135,9 @@ def compare_reactor_doe():
             *doe_obj_grey_box.results["Experiment Design"][1:]
         )
     )
-    print("FIM at optimal design:\n {}".format(np.array(doe_obj_grey_box.results["FIM"])))
+    print("FIM at optimal design with grey-box:\n {}".format(np.array(doe_obj_grey_box.results["FIM"])))
     print(
-        "Objective value at optimal design: {:.2f}".format(
+        "Objective value at optimal design with grey-box: {:.2f}".format(
             pyo.value(doe_obj_grey_box.model.objective)
         )
     )

From 1d53b5a21377b54e902de33ac69da3cc8bb19796 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 13 Mar 2025 12:57:28 -0400
Subject: [PATCH 013/143] generalizing to E-opt

Trying to explore hessian option to make these things converge better. Need to explore more tensor calculus.
---
 pyomo/contrib/doe/doe.py                     |  12 ++-
 pyomo/contrib/doe/examples/grey_box_E_opt.py | 100 +++++++++++++++++
 pyomo/contrib/doe/grey_box_utilities.py      | 106 ++++++++++++-------
 3 files changed, 175 insertions(+), 43 deletions(-)
 create mode 100644 pyomo/contrib/doe/examples/grey_box_E_opt.py

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index 6bd8e120c4c..6536ef48ea6 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -307,9 +307,15 @@ def FIM_egb_cons(m, p1, p2):
             
             # ToDo: Add naming convention to adjust name of objective output
             # to conincide with the ObjectiveLib type
-            # Proposal --> Use alphabetic opt e.g., ``A-opt``, ``D-opt``, etc.
-            # Add objective function from FIM grey box calculation
-            model.objective = pyo.Objective(expr=model.obj_cons.egb_fim_block.outputs["log_det"], sense=pyo.maximize)  # Must change hardcoding
+            # ToDo: Write test for each option successfully building
+            if self.objective_option == ObjectiveLib.determinant:
+                model.objective = pyo.Objective(expr=model.obj_cons.egb_fim_block.outputs["log10-D-opt"], sense=pyo.maximize)
+            elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
+                model.objective = pyo.Objective(expr=model.obj_cons.egb_fim_block.outputs["log10-E-opt"], sense=pyo.maximize)
+            else:
+                raise AttributeError(
+                    "Objective option not recognized. Please contact the developers as you should not see this error."
+                )
         else:
             self.create_objective_function(model=model)
 
diff --git a/pyomo/contrib/doe/examples/grey_box_E_opt.py b/pyomo/contrib/doe/examples/grey_box_E_opt.py
new file mode 100644
index 00000000000..b0bf5e3aee9
--- /dev/null
+++ b/pyomo/contrib/doe/examples/grey_box_E_opt.py
@@ -0,0 +1,100 @@
+#  ___________________________________________________________________________
+#
+#  Pyomo: Python Optimization Modeling Objects
+#  Copyright (c) 2008-2024
+#  National Technology and Engineering Solutions of Sandia, LLC
+#  Under the terms of Contract DE-NA0003525 with National Technology and
+#  Engineering Solutions of Sandia, LLC, the U.S. Government retains certain
+#  rights in this software.
+#  This software is distributed under the 3-clause BSD License.
+#  ___________________________________________________________________________
+from pyomo.common.dependencies import numpy as np
+
+from pyomo.contrib.doe.examples.reactor_experiment import ReactorExperiment
+from pyomo.contrib.doe import DesignOfExperiments
+
+import pyomo.environ as pyo
+
+import json
+import logging
+from pathlib import Path
+
+
+# Seeing if D-optimal experiment matches for both the
+# greybox objective and the algebraic objective
+def compare_reactor_doe():
+    # Read in file
+    DATA_DIR = Path(__file__).parent
+    file_path = DATA_DIR / "result.json"
+
+    with open(file_path) as f:
+        data_ex = json.load(f)
+
+    # Put temperature control time points into correct format for reactor experiment
+    data_ex["control_points"] = {
+        float(k): v for k, v in data_ex["control_points"].items()
+    }
+
+    # Create a ReactorExperiment object; data and discretization information are part
+    # of the constructor of this object
+    experiment = ReactorExperiment(data=data_ex, nfe=10, ncp=3)
+
+    # Use a central difference, with step size 1e-3
+    fd_formula = "central"
+    step_size = 1e-3
+
+    # Use the determinant objective with scaled sensitivity matrix
+    objective_option = "minimum_eigenvalue"
+    scale_nominal_param_value = True
+
+    solver = pyo.SolverFactory("ipopt")
+    solver.options["linear_solver"] = "mumps"
+
+    # Begin optimal grey box DoE
+    ############################
+    doe_obj_grey_box = DesignOfExperiments(
+        experiment,
+        fd_formula=fd_formula,
+        step=step_size,
+        objective_option=objective_option,
+        use_grey_box_objective=True,  # New object with grey box set to True
+        scale_constant_value=1,
+        scale_nominal_param_value=scale_nominal_param_value,
+        prior_FIM=None,
+        jac_initial=None,
+        fim_initial=None,
+        L_diagonal_lower_bound=1e-7,
+        solver=solver,
+        tee=True,
+        get_labeled_model_args=None,
+        #logger_level=logging.ERROR,
+        _Cholesky_option=True,
+        _only_compute_fim_lower=True,
+    )
+
+    doe_obj_grey_box.run_doe()
+    # Print out a results summary                                                                                                                      
+    print("Optimal experiment values with grey-box: ")
+    print(
+        "\tInitial concentration: {:.2f}".format(
+            doe_obj_grey_box.results["Experiment Design"][0]
+        )
+    )
+    print(
+        ("\tTemperature values: [" + "{:.2f}, " * 8 + "{:.2f}]").format(
+            *doe_obj_grey_box.results["Experiment Design"][1:]
+        )
+    )
+    print("FIM at optimal design with grey-box:\n {}".format(np.array(doe_obj_grey_box.results["FIM"])))
+    print(
+        "Objective value at optimal design with grey-box: {:.2f}".format(
+            pyo.value(doe_obj_grey_box.model.objective)
+        )
+    )
+    print("Raw logdet: {:.2f}".format(np.log10(np.linalg.det(np.array(doe_obj_grey_box.results["FIM"])))))
+
+    print(doe_obj_grey_box.results["Experiment Design Names"])
+
+    
+if __name__ == "__main__":
+    compare_reactor_doe()
diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index 24cb4b36386..2d8dbf0fc75 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -38,12 +38,20 @@
 
 import pyomo.environ as pyo
 
+# Remove this and utilize pyomo.contrib.doe 
+# but resolve the circular import issue.
+class ObjectiveLib(Enum):
+    determinant = "determinant"
+    trace = "trace"
+    minimum_eigenvalue = "minimum_eigenvalue"
+    zero = "zero"
+
 
 class FIMExternalGreyBox(ExternalGreyBoxModel):
     def __init__(
             self,
             doe_object,
-            objective_option="determinant",
+            objective_option=ObjectiveLib.determinant,
             logger_level=None,
     ):
         """
@@ -77,7 +85,7 @@ def __init__(
         # Check if the doe_object has model components that are required
         # TODO: add checks for the model --> doe_object.model needs FIM; all other checks should
         #       have been satisfied before the FIM is created. Can add check for unknown_parameters...
-        self.objective_option = objective_option.name  # Add failsafe to make sure this is ObjectiveLib object?
+        self.objective_option = objective_option  # Add failsafe to make sure this is ObjectiveLib object?
         # Will anyone ever call this without calling DoE? --> intended to be no; but maybe more utility?
 
         # Create logger for FIM egb object
@@ -108,7 +116,12 @@ def output_names(self):
         # an input from the user. Or it could depend on the usage of
         # the ObjectiveLib Enum object, which should have an associated
         # name for the objective function at all times.
-        return ["log_det", ]  # Change for hard-coded D-optimality
+        from pyomo.contrib.doe import ObjectiveLib
+        if self.objective_option == ObjectiveLib.determinant:
+            obj_name = "log10-D-opt"
+        elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
+            obj_name = "log10-E-opt"
+        return [obj_name, ]
 
     def set_input_values(self, input_values):
         # Set initial values to be flattened initial FIM (aligns with input names)
@@ -120,21 +133,21 @@ def evaluate_equality_constraints(self):
         return None
 
     def evaluate_outputs(self):
-        # ToDo: Take the objective function option and perform the
-        # mathematical action to get the objective.
-
-        # CALCULATE THE INVERSE VALUE
-        # CHANGE HARD-CODED LOG DET
+        # Evaluates the objective value for the specified
+        # ObjectiveLib type.
         current_FIM = self._input_values
         M = np.asarray(current_FIM, dtype=np.float64).reshape(len(self._param_names), len(self._param_names))
-
-        # Trying symmetry calculation?
-        #M = np.multiply(M, np.tril(np.ones((len(self._param_names), len(self._param_names)))))
-        #M = M + M.transpose() - np.multiply(M, np.eye(len(self._param_names)))
         
-        (sign, logdet) = np.linalg.slogdet(M)
+        # Change objective value based on ObjectiveLib type.
+        from pyomo.contrib.doe import ObjectiveLib
+        if self.objective_option == ObjectiveLib.determinant:
+            (sign, logdet) = np.linalg.slogdet(M)
+            obj_value = logdet
+        elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
+            eig, _ = np.linalg.eig(M)
+            obj_value = np.min(eig)
         
-        return np.asarray([logdet, ], dtype=np.float64)
+        return np.asarray([obj_value, ], dtype=np.float64)
 
     def finalize_block_construction(self, pyomo_block):
         # Set bounds on the inputs/outputs
@@ -146,7 +159,11 @@ def finalize_block_construction(self, pyomo_block):
             pyomo_block.inputs[val] = self.doe_object.fim_initial.flatten()[ind]
 
         # Initialize log_determinant value
-        pyomo_block.outputs["log_det"] = 0  # Remember to change hardcoded name
+        from pyomo.contrib.doe import ObjectiveLib
+        if self.objective_option == ObjectiveLib.determinant:
+            pyomo_block.outputs["log10-D-opt"] = 0
+        elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
+            pyomo_block.outputs["log10-E-opt"] = 0
 
     def evaluate_jacobian_equality_constraints(self):
         # ToDo: Do any objectives require constraints?
@@ -155,7 +172,7 @@ def evaluate_jacobian_equality_constraints(self):
         return None
         
     def evaluate_jacobian_outputs(self):
-        # ToDo: compute the jacobian of the objective function with
+        # Compute the jacobian of the objective function with
         # respect to the fisher information matrix. Then return
         # a coo_matrix that aligns with what IPOPT will expect.
         #
@@ -163,31 +180,40 @@ def evaluate_jacobian_outputs(self):
         # complicated objective functions and the Hessian        
         current_FIM = self._input_values
         M = np.asarray(current_FIM, dtype=np.float64).reshape(len(self._param_names), len(self._param_names))
-
-        # Trying symmetry calculation?
-        #M = np.multiply(M, np.tril(np.ones((len(self._param_names), len(self._param_names)))))
-        #M = M + M.transpose() - np.multiply(M, np.eye(len(self._param_names)))
         
-        Minv = np.linalg.pinv(M)
-        eig, _ = np.linalg.eig(M)
-        if min(eig) <= 1:
-            print("Warning: {:0.6f}".format(min(eig)))
-
-        # Since M is symmetric, the derivative of logdet(M) w.r.t M is
-        # 2*inverse(M) - diagonal(inverse(M)) ADD SOURCE
-        #jac_M = 2*Minv - np.diagonal(Minv)
-        #jac_M = Minv
-
-        jac_M = 0.5*(Minv + Minv.transpose())
-
-        #print("M")
-        #print(M)
-        #print("Jac_M")
-        #print(jac_M)
-        #print("Eigenvalues")
-        #print(eig)
-        #print("Eigenvectors")
-        #print(_)
+        # May remove this warning. If so, we
+        # should put the eigenvalue computation
+        # within the eigenvalue-dependent
+        # objective options...
+        eig_vals, eig_vecs = np.linalg.eig(M)
+        if min(eig_vals) <= 1:
+            pass
+            print("Warning: {:0.6f}".format(min(eig_vals)))
+
+        from pyomo.contrib.doe import ObjectiveLib
+        if self.objective_option == ObjectiveLib.determinant:
+            Minv = np.linalg.pinv(M)
+            # Derivative formula derived using tensor
+            # calculus. Add reference to pyomo.DoE 2.0
+            # manuscript S.I.
+            jac_M = 0.5*(Minv + Minv.transpose())
+        elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
+            # Obtain minimum eigenvalue location
+            min_eig_loc = np.argmin(eig_vals)
+
+            # Grab eigenvector associated with
+            # the minimum eigenvalue and make
+            # it a matrix. This is so we can
+            # use matrix operations later in
+            # the code.
+            min_eig_vec = np.array([eig_vecs[:, min_eig_loc]])
+        
+            # Calculate the derivative matrix.
+            # This is the hadamard product of
+            # the eigenvector we grabbed in
+            # the previous line of code.
+            jac_M = min_eig_vec * np.transpose(min_eig_vec)
+
 
         # Rows are the integer division by number of columns
         M_rows = np.arange(len(jac_M.flatten())) // jac_M.shape[1]

From 4773e939de23daacb49340c4f6da4b056ee751b9 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 13 Mar 2025 14:06:52 -0400
Subject: [PATCH 014/143] more brief changes

Need to try some other numerical things to encourage convergence before attacking Hessian problem...
---
 pyomo/contrib/doe/doe.py                |  8 +++++++-
 pyomo/contrib/doe/grey_box_utilities.py | 16 ++++++----------
 2 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index 6536ef48ea6..d50716bf7f1 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -211,7 +211,7 @@ def __init__(
             grey_box_solver.config.options['hessian_approximation'] = 'limited-memory'
             #grey_box_solver.config.options["linear_solver"] = "ma57" 
             grey_box_solver.config.options['max_iter'] = 3000
-            grey_box_solver.config.options['tol'] = 1e-4
+            grey_box_solver.config.options['tol'] = 2e-3
             #grey_box_solver.config.options['mu_strategy'] = "monotone"
 
             self.grey_box_solver = grey_box_solver
@@ -342,6 +342,9 @@ def FIM_egb_cons(m, p1, p2):
         #     # The solver was unsuccessful, might want to warn the user or terminate gracefully, etc.
         model.dummy_obj = pyo.Objective(expr=0, sense=pyo.minimize)
         self.solver.solve(model, tee=self.tee)
+        from idaes.core.util import DiagnosticsToolbox
+        dt = DiagnosticsToolbox(model)
+        dt.display_extreme_jacobian_entries()
 
         # Track time to initialize the DoE model
         initialization_time = sp_timer.toc(msg=None)
@@ -387,6 +390,9 @@ def FIM_egb_cons(m, p1, p2):
         # Solve the full model, which has now been initialized with the square solve
         if self.use_grey_box:
             res = self.grey_box_solver.solve(model, tee=self.tee)
+            # from idaes.core.util import DiagnosticsToolbox
+            # dt = DiagnosticsToolbox(model)
+            # dt.report_numerical_issues()
         else:
             res = self.solver.solve(model, tee=self.tee)
 
diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index 2d8dbf0fc75..3148a3c5308 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -38,20 +38,12 @@
 
 import pyomo.environ as pyo
 
-# Remove this and utilize pyomo.contrib.doe 
-# but resolve the circular import issue.
-class ObjectiveLib(Enum):
-    determinant = "determinant"
-    trace = "trace"
-    minimum_eigenvalue = "minimum_eigenvalue"
-    zero = "zero"
-
 
 class FIMExternalGreyBox(ExternalGreyBoxModel):
     def __init__(
             self,
             doe_object,
-            objective_option=ObjectiveLib.determinant,
+            objective_option="determinant",
             logger_level=None,
     ):
         """
@@ -99,11 +91,13 @@ def __init__(
 
         # Set initial values for inputs
         self._input_values = np.asarray(self.doe_object.fim_initial.flatten(), dtype=np.float64)
-        print(self._input_values)
+        #print(self._input_values)
 
     
     def input_names(self):
         # Cartesian product gives us matrix indicies flattened in row-first format
+        # Can use itertools.combinations(self._param_names, 2) with added
+        # diagonal elements, or do double for loops if we switch to upper triangular
         input_names_list = list(itertools.product(self._param_names, self._param_names))
         return input_names_list
 
@@ -186,6 +180,8 @@ def evaluate_jacobian_outputs(self):
         # within the eigenvalue-dependent
         # objective options...
         eig_vals, eig_vecs = np.linalg.eig(M)
+        #print("Conditon number:")
+        #print(np.linalg.cond(M))
         if min(eig_vals) <= 1:
             pass
             print("Warning: {:0.6f}".format(min(eig_vals)))

From 0298309be08757d41d2dfb1af806e20bc20ebdc7 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 27 Mar 2025 08:47:35 -0400
Subject: [PATCH 015/143] Added ME optimality

Added option for condition number optimality. Last step will be to potentially change to triangular definition of inputs in grey-box function, then add Hessian computation.
---
 pyomo/contrib/doe/doe.py                      |  13 ++-
 pyomo/contrib/doe/examples/grey_box_ME_opt.py | 100 ++++++++++++++++++
 pyomo/contrib/doe/grey_box_utilities.py       |  45 +++++++-
 3 files changed, 150 insertions(+), 8 deletions(-)
 create mode 100644 pyomo/contrib/doe/examples/grey_box_ME_opt.py

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index d50716bf7f1..a6a73f0219a 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -58,6 +58,7 @@ class ObjectiveLib(Enum):
     determinant = "determinant"
     trace = "trace"
     minimum_eigenvalue = "minimum_eigenvalue"
+    condition_number = "condition_number"
     zero = "zero"
 
 
@@ -211,7 +212,7 @@ def __init__(
             grey_box_solver.config.options['hessian_approximation'] = 'limited-memory'
             #grey_box_solver.config.options["linear_solver"] = "ma57" 
             grey_box_solver.config.options['max_iter'] = 3000
-            grey_box_solver.config.options['tol'] = 2e-3
+            grey_box_solver.config.options['tol'] = 1e-5
             #grey_box_solver.config.options['mu_strategy'] = "monotone"
 
             self.grey_box_solver = grey_box_solver
@@ -311,7 +312,9 @@ def FIM_egb_cons(m, p1, p2):
             if self.objective_option == ObjectiveLib.determinant:
                 model.objective = pyo.Objective(expr=model.obj_cons.egb_fim_block.outputs["log10-D-opt"], sense=pyo.maximize)
             elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
-                model.objective = pyo.Objective(expr=model.obj_cons.egb_fim_block.outputs["log10-E-opt"], sense=pyo.maximize)
+                model.objective = pyo.Objective(expr=model.obj_cons.egb_fim_block.outputs["E-opt"], sense=pyo.maximize)
+            elif self.objective_option == ObjectiveLib.condition_number:
+                model.objective = pyo.Objective(expr=model.obj_cons.egb_fim_block.outputs["ME-opt"], sense=pyo.minimize)
             else:
                 raise AttributeError(
                     "Objective option not recognized. Please contact the developers as you should not see this error."
@@ -342,9 +345,9 @@ def FIM_egb_cons(m, p1, p2):
         #     # The solver was unsuccessful, might want to warn the user or terminate gracefully, etc.
         model.dummy_obj = pyo.Objective(expr=0, sense=pyo.minimize)
         self.solver.solve(model, tee=self.tee)
-        from idaes.core.util import DiagnosticsToolbox
-        dt = DiagnosticsToolbox(model)
-        dt.display_extreme_jacobian_entries()
+        # from idaes.core.util import DiagnosticsToolbox
+        # dt = DiagnosticsToolbox(model)
+        # dt.display_extreme_jacobian_entries()
 
         # Track time to initialize the DoE model
         initialization_time = sp_timer.toc(msg=None)
diff --git a/pyomo/contrib/doe/examples/grey_box_ME_opt.py b/pyomo/contrib/doe/examples/grey_box_ME_opt.py
new file mode 100644
index 00000000000..9a0665d9c9a
--- /dev/null
+++ b/pyomo/contrib/doe/examples/grey_box_ME_opt.py
@@ -0,0 +1,100 @@
+#  ___________________________________________________________________________
+#
+#  Pyomo: Python Optimization Modeling Objects
+#  Copyright (c) 2008-2024
+#  National Technology and Engineering Solutions of Sandia, LLC
+#  Under the terms of Contract DE-NA0003525 with National Technology and
+#  Engineering Solutions of Sandia, LLC, the U.S. Government retains certain
+#  rights in this software.
+#  This software is distributed under the 3-clause BSD License.
+#  ___________________________________________________________________________
+from pyomo.common.dependencies import numpy as np
+
+from pyomo.contrib.doe.examples.reactor_experiment import ReactorExperiment
+from pyomo.contrib.doe import DesignOfExperiments
+
+import pyomo.environ as pyo
+
+import json
+import logging
+from pathlib import Path
+
+
+# Seeing if D-optimal experiment matches for both the
+# greybox objective and the algebraic objective
+def compare_reactor_doe():
+    # Read in file
+    DATA_DIR = Path(__file__).parent
+    file_path = DATA_DIR / "result.json"
+
+    with open(file_path) as f:
+        data_ex = json.load(f)
+
+    # Put temperature control time points into correct format for reactor experiment
+    data_ex["control_points"] = {
+        float(k): v for k, v in data_ex["control_points"].items()
+    }
+
+    # Create a ReactorExperiment object; data and discretization information are part
+    # of the constructor of this object
+    experiment = ReactorExperiment(data=data_ex, nfe=10, ncp=3)
+
+    # Use a central difference, with step size 1e-3
+    fd_formula = "central"
+    step_size = 1e-3
+
+    # Use the determinant objective with scaled sensitivity matrix
+    objective_option = "condition_number"
+    scale_nominal_param_value = True
+
+    solver = pyo.SolverFactory("ipopt")
+    solver.options["linear_solver"] = "mumps"
+
+    # Begin optimal grey box DoE
+    ############################
+    doe_obj_grey_box = DesignOfExperiments(
+        experiment,
+        fd_formula=fd_formula,
+        step=step_size,
+        objective_option=objective_option,
+        use_grey_box_objective=True,  # New object with grey box set to True
+        scale_constant_value=1,
+        scale_nominal_param_value=scale_nominal_param_value,
+        prior_FIM=None,
+        jac_initial=None,
+        fim_initial=None,
+        L_diagonal_lower_bound=1e-7,
+        solver=solver,
+        tee=True,
+        get_labeled_model_args=None,
+        #logger_level=logging.ERROR,
+        _Cholesky_option=True,
+        _only_compute_fim_lower=True,
+    )
+
+    doe_obj_grey_box.run_doe()
+    # Print out a results summary                                                                                                                      
+    print("Optimal experiment values with grey-box: ")
+    print(
+        "\tInitial concentration: {:.2f}".format(
+            doe_obj_grey_box.results["Experiment Design"][0]
+        )
+    )
+    print(
+        ("\tTemperature values: [" + "{:.2f}, " * 8 + "{:.2f}]").format(
+            *doe_obj_grey_box.results["Experiment Design"][1:]
+        )
+    )
+    print("FIM at optimal design with grey-box:\n {}".format(np.array(doe_obj_grey_box.results["FIM"])))
+    print(
+        "Objective value at optimal design with grey-box: {:.2f}".format(
+            pyo.value(doe_obj_grey_box.model.objective)
+        )
+    )
+    print("Raw logdet: {:.2f}".format(np.log10(np.linalg.det(np.array(doe_obj_grey_box.results["FIM"])))))
+
+    print(doe_obj_grey_box.results["Experiment Design Names"])
+
+    
+if __name__ == "__main__":
+    compare_reactor_doe()
diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index 3148a3c5308..142a06ca3eb 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -114,7 +114,9 @@ def output_names(self):
         if self.objective_option == ObjectiveLib.determinant:
             obj_name = "log10-D-opt"
         elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
-            obj_name = "log10-E-opt"
+            obj_name = "E-opt"
+        elif self.objective_option == ObjectiveLib.condition_number:
+            obj_name = "ME-opt"
         return [obj_name, ]
 
     def set_input_values(self, input_values):
@@ -140,6 +142,9 @@ def evaluate_outputs(self):
         elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
             eig, _ = np.linalg.eig(M)
             obj_value = np.min(eig)
+        elif self.objective_option == ObjectiveLib.condition_number:
+            eig, _ = np.linalg.eig(M)
+            obj_value = np.max(eig) / np.min(eig)
         
         return np.asarray([obj_value, ], dtype=np.float64)
 
@@ -157,7 +162,9 @@ def finalize_block_construction(self, pyomo_block):
         if self.objective_option == ObjectiveLib.determinant:
             pyomo_block.outputs["log10-D-opt"] = 0
         elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
-            pyomo_block.outputs["log10-E-opt"] = 0
+            pyomo_block.outputs["E-opt"] = 0
+        elif self.objective_option == ObjectiveLib.condition_number:
+            pyomo_block.outputs["ME-opt"] = 0
 
     def evaluate_jacobian_equality_constraints(self):
         # ToDo: Do any objectives require constraints?
@@ -205,10 +212,42 @@ def evaluate_jacobian_outputs(self):
             min_eig_vec = np.array([eig_vecs[:, min_eig_loc]])
         
             # Calculate the derivative matrix.
-            # This is the hadamard product of
+            # This is the expansion product of
             # the eigenvector we grabbed in
             # the previous line of code.
             jac_M = min_eig_vec * np.transpose(min_eig_vec)
+        elif self.objective_option == ObjectiveLib.condition_number:
+            # Obtain minimum (and maximum) eigenvalue location(s)
+            min_eig_loc = np.argmin(eig_vals)
+            max_eig_loc = np.argmax(eig_vals)
+
+            min_eig = np.min(eig_vals)
+            max_eig = np.max(eig_vals)
+
+            # Grab eigenvector associated with
+            # the min (and max) eigenvalue and make
+            # it a matrix. This is so we can
+            # use matrix operations later in
+            # the code.
+            min_eig_vec = np.array([eig_vecs[:, min_eig_loc]])
+            max_eig_vec = np.array([eig_vecs[:, min_eig_loc]])
+
+            # Calculate the derivative matrix.
+            # Similar to minimum eigenvalue,
+            # this computation involves two
+            # expansion products.
+            min_eig_term = min_eig_vec * np.transpose(min_eig_vec)
+            max_eig_term = min_eig_vec * np.transpose(min_eig_vec)
+
+            min_eig_epsilon = 1e-8
+
+            # Computing a (hopefully) nonsingular
+            # condition number for the jacobian
+            # expression.
+            safe_cond_number = max_eig / (min_eig + np.sign(min_eig) * min_eig_epsilon)
+
+            # Combing the expression
+            jac_M = 1 / (min_eig + np.sign(min_eig) * min_eig_epsilon) * (max_eig_term - safe_cond_number * min_eig_term)
 
 
         # Rows are the integer division by number of columns

From 81fea9f28fe50060a68e2439c9203f238d6492e1 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 27 Mar 2025 09:29:44 -0400
Subject: [PATCH 016/143] Changed to lower triangle FIM

Should improve computational performance. Seemed to help E and ME but D still has issues. Next steps would be to add the Hessian calculation.
---
 pyomo/contrib/doe/doe.py                |  7 ++--
 pyomo/contrib/doe/grey_box_utilities.py | 56 ++++++++++++++++++-------
 2 files changed, 46 insertions(+), 17 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index a6a73f0219a..8bf03348077 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -300,10 +300,10 @@ def FIM_egb_cons(m, p1, p2):
                 p2: parameter 2
                 
                 """
-                if list(model.parameter_names).index(p1) >= list(model.parameter_names).index(p2):
+                if list(model.parameter_names).index(p1) <= list(model.parameter_names).index(p2):
                     return model.fim[(p1, p2)] == m.egb_fim_block.inputs[(p1, p2)]
                 else:
-                    return model.fim[(p2, p1)] == m.egb_fim_block.inputs[(p1, p2)]
+                    return pyo.Constraint.Skip
             model.obj_cons.FIM_equalities = pyo.Constraint(model.parameter_names, model.parameter_names, rule=FIM_egb_cons)
             
             # ToDo: Add naming convention to adjust name of objective output
@@ -368,7 +368,8 @@ def FIM_egb_cons(m, p1, p2):
             # Initialize grey box inputs to be fim values currently
             for i in model.parameter_names:
                 for j in model.parameter_names:
-                    model.obj_cons.egb_fim_block.inputs[(i, j)].set_value(pyo.value(model.fim[(i, j)]))
+                    if list(model.parameter_names).index(i) <= list(model.parameter_names).index(j):
+                        model.obj_cons.egb_fim_block.inputs[(i, j)].set_value(pyo.value(model.fim[(i, j)]))
         
         # If the model has L, initialize it with the solved FIM
         if hasattr(model, "L"):
diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index 142a06ca3eb..bd76f9b1c11 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -90,8 +90,27 @@ def __init__(
         self.logger.setLevel(level=logger_level)
 
         # Set initial values for inputs
-        self._input_values = np.asarray(self.doe_object.fim_initial.flatten(), dtype=np.float64)
+        # Need a mask structure
+        self._masking_matrix = np.tril(np.ones_like(self.doe_object.fim_initial))
+        #self._input_values = np.asarray(self.doe_object.fim_initial.flatten(), dtype=np.float64)
+        self._input_values = np.asarray(self.doe_object.fim_initial[self._masking_matrix > 0], dtype=np.float64)
         #print(self._input_values)
+    
+
+    def _get_FIM(self):
+        # Grabs the current FIM subject
+        # to the input values.
+        # This function currently assumes
+        # that we use a lower triangular
+        # FIM.
+        lowt_FIM = self._input_values
+
+        # Create FIM in the correct way
+        current_FIM = np.ones_like(self.doe_object.fim_initial)
+        current_FIM[np.tril_indices_from(current_FIM)] = lowt_FIM
+        current_FIM[np.triu_indices_from(current_FIM)] = lowt_FIM
+
+        return current_FIM
 
     
     def input_names(self):
@@ -99,6 +118,8 @@ def input_names(self):
         # Can use itertools.combinations(self._param_names, 2) with added
         # diagonal elements, or do double for loops if we switch to upper triangular
         input_names_list = list(itertools.product(self._param_names, self._param_names))
+        input_names_list = [(self._param_names[i[0]], self._param_names[i[1] - 1]) 
+                            for i in itertools.combinations(range(len(self._param_names) + 1), 2)]
         return input_names_list
 
     def equality_constraint_names(self):
@@ -131,7 +152,8 @@ def evaluate_equality_constraints(self):
     def evaluate_outputs(self):
         # Evaluates the objective value for the specified
         # ObjectiveLib type.
-        current_FIM = self._input_values
+        current_FIM = self._get_FIM()
+
         M = np.asarray(current_FIM, dtype=np.float64).reshape(len(self._param_names), len(self._param_names))
         
         # Change objective value based on ObjectiveLib type.
@@ -179,7 +201,7 @@ def evaluate_jacobian_outputs(self):
         #
         # ToDo: there will be significant bookkeeping for more
         # complicated objective functions and the Hessian        
-        current_FIM = self._input_values
+        current_FIM = self._get_FIM()
         M = np.asarray(current_FIM, dtype=np.float64).reshape(len(self._param_names), len(self._param_names))
         
         # May remove this warning. If so, we
@@ -230,14 +252,14 @@ def evaluate_jacobian_outputs(self):
             # use matrix operations later in
             # the code.
             min_eig_vec = np.array([eig_vecs[:, min_eig_loc]])
-            max_eig_vec = np.array([eig_vecs[:, min_eig_loc]])
+            max_eig_vec = np.array([eig_vecs[:, max_eig_loc]])
 
             # Calculate the derivative matrix.
             # Similar to minimum eigenvalue,
             # this computation involves two
             # expansion products.
             min_eig_term = min_eig_vec * np.transpose(min_eig_vec)
-            max_eig_term = min_eig_vec * np.transpose(min_eig_vec)
+            max_eig_term = max_eig_vec * np.transpose(max_eig_vec)
 
             min_eig_epsilon = 1e-8
 
@@ -246,21 +268,27 @@ def evaluate_jacobian_outputs(self):
             # expression.
             safe_cond_number = max_eig / (min_eig + np.sign(min_eig) * min_eig_epsilon)
 
-            # Combing the expression
+            # Combining the expression
             jac_M = 1 / (min_eig + np.sign(min_eig) * min_eig_epsilon) * (max_eig_term - safe_cond_number * min_eig_term)
 
 
-        # Rows are the integer division by number of columns
-        M_rows = np.arange(len(jac_M.flatten())) // jac_M.shape[1]
+        # Filter jac_M using the
+        # masking matrix
+        jac_M = jac_M[self._masking_matrix > 0]
+        M_rows = np.zeros_like(jac_M)
+        M_cols = np.arange(len(jac_M))
+
+        # # Rows are the integer division by number of columns
+        # M_rows = np.arange(len(jac_M.flatten())) // jac_M.shape[1]
 
-        # Columns are the remaindar (mod) by number of rows
-        M_cols = np.arange(len(jac_M.flatten())) % jac_M.shape[0]
+        # # Columns are the remaindar (mod) by number of rows
+        # M_cols = np.arange(len(jac_M.flatten())) % jac_M.shape[0]
 
-        # Need to be flat?
-        M_rows = np.zeros((len(jac_M.flatten()), 1)).flatten()
+        # # Need to be flat?
+        # M_rows = np.zeros((len(jac_M.flatten()), 1)).flatten()
 
-        # Need to be flat?
-        M_cols = np.arange(len(jac_M.flatten()))
+        # # Need to be flat?
+        # M_cols = np.arange(len(jac_M.flatten()))
         
         # Returns coo_matrix of the correct shape
         #print(coo_matrix((jac_M.flatten(), (M_rows, M_cols)), shape=(1, len(jac_M.flatten()))))

From 5faf6da89f7e0eefec94520f76c438b15eb89ae6 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 27 Mar 2025 09:31:35 -0400
Subject: [PATCH 017/143] Ran Black

---
 pyomo/contrib/doe/doe.py                      |  58 ++++++---
 .../doe/examples/grey_box_D_opt_comparison.py |  20 ++-
 pyomo/contrib/doe/examples/grey_box_E_opt.py  |  18 ++-
 pyomo/contrib/doe/examples/grey_box_ME_opt.py |  18 ++-
 pyomo/contrib/doe/examples/grey_box_test.py   |  62 ++++-----
 pyomo/contrib/doe/grey_box_utilities.py       | 119 ++++++++++--------
 6 files changed, 182 insertions(+), 113 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index 8bf03348077..f32ef2906e8 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -195,7 +195,7 @@ def __init__(
         # if not given, use default solver
         else:
             solver = pyo.SolverFactory("ipopt")
-            #solver.options["linear_solver"] = "ma57"
+            # solver.options["linear_solver"] = "ma57"
             solver.options["linear_solver"] = "MUMPS"
             solver.options["halt_on_ampl_error"] = "yes"
             solver.options["max_iter"] = 3000
@@ -210,10 +210,10 @@ def __init__(
         else:
             grey_box_solver = pyo.SolverFactory("cyipopt")
             grey_box_solver.config.options['hessian_approximation'] = 'limited-memory'
-            #grey_box_solver.config.options["linear_solver"] = "ma57" 
+            # grey_box_solver.config.options["linear_solver"] = "ma57"
             grey_box_solver.config.options['max_iter'] = 3000
             grey_box_solver.config.options['tol'] = 1e-5
-            #grey_box_solver.config.options['mu_strategy'] = "monotone"
+            # grey_box_solver.config.options['mu_strategy'] = "monotone"
 
             self.grey_box_solver = grey_box_solver
 
@@ -288,33 +288,53 @@ def run_doe(self, model=None, results_file=None):
             # ToDo: Make this naming convention robust
             model.obj_cons = pyo.Block()
             # ToDo: Add functionality for grey box objectives
-            grey_box_FIM = FIMExternalGreyBox(doe_object=self, objective_option=self.objective_option, logger_level=self.logger.getEffectiveLevel())
-            model.obj_cons.egb_fim_block = ExternalGreyBoxBlock(external_model=grey_box_FIM)
+            grey_box_FIM = FIMExternalGreyBox(
+                doe_object=self,
+                objective_option=self.objective_option,
+                logger_level=self.logger.getEffectiveLevel(),
+            )
+            model.obj_cons.egb_fim_block = ExternalGreyBoxBlock(
+                external_model=grey_box_FIM
+            )
 
             # Adding constraints to for all grey box input values to equate to fim values
             def FIM_egb_cons(m, p1, p2):
                 """
-                
+
                 m: Pyomo model
                 p1: parameter 1
                 p2: parameter 2
-                
+
                 """
-                if list(model.parameter_names).index(p1) <= list(model.parameter_names).index(p2):
+                if list(model.parameter_names).index(p1) <= list(
+                    model.parameter_names
+                ).index(p2):
                     return model.fim[(p1, p2)] == m.egb_fim_block.inputs[(p1, p2)]
                 else:
                     return pyo.Constraint.Skip
-            model.obj_cons.FIM_equalities = pyo.Constraint(model.parameter_names, model.parameter_names, rule=FIM_egb_cons)
-            
+
+            model.obj_cons.FIM_equalities = pyo.Constraint(
+                model.parameter_names, model.parameter_names, rule=FIM_egb_cons
+            )
+
             # ToDo: Add naming convention to adjust name of objective output
             # to conincide with the ObjectiveLib type
             # ToDo: Write test for each option successfully building
             if self.objective_option == ObjectiveLib.determinant:
-                model.objective = pyo.Objective(expr=model.obj_cons.egb_fim_block.outputs["log10-D-opt"], sense=pyo.maximize)
+                model.objective = pyo.Objective(
+                    expr=model.obj_cons.egb_fim_block.outputs["log10-D-opt"],
+                    sense=pyo.maximize,
+                )
             elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
-                model.objective = pyo.Objective(expr=model.obj_cons.egb_fim_block.outputs["E-opt"], sense=pyo.maximize)
+                model.objective = pyo.Objective(
+                    expr=model.obj_cons.egb_fim_block.outputs["E-opt"],
+                    sense=pyo.maximize,
+                )
             elif self.objective_option == ObjectiveLib.condition_number:
-                model.objective = pyo.Objective(expr=model.obj_cons.egb_fim_block.outputs["ME-opt"], sense=pyo.minimize)
+                model.objective = pyo.Objective(
+                    expr=model.obj_cons.egb_fim_block.outputs["ME-opt"],
+                    sense=pyo.minimize,
+                )
             else:
                 raise AttributeError(
                     "Objective option not recognized. Please contact the developers as you should not see this error."
@@ -368,9 +388,13 @@ def FIM_egb_cons(m, p1, p2):
             # Initialize grey box inputs to be fim values currently
             for i in model.parameter_names:
                 for j in model.parameter_names:
-                    if list(model.parameter_names).index(i) <= list(model.parameter_names).index(j):
-                        model.obj_cons.egb_fim_block.inputs[(i, j)].set_value(pyo.value(model.fim[(i, j)]))
-        
+                    if list(model.parameter_names).index(i) <= list(
+                        model.parameter_names
+                    ).index(j):
+                        model.obj_cons.egb_fim_block.inputs[(i, j)].set_value(
+                            pyo.value(model.fim[(i, j)])
+                        )
+
         # If the model has L, initialize it with the solved FIM
         if hasattr(model, "L"):
             # Get the FIM values
@@ -1167,7 +1191,7 @@ def build_block_scenarios(b, s):
             # Fix experiment inputs before solve (enforce square solve)
             for comp in b.experiment_inputs:
                 comp.fix()
-                
+
             res = self.solver.solve(b, tee=self.tee)
 
             # Unfix experiment inputs after square solve
diff --git a/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py b/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
index 8e7018863a5..763b2620d0d 100644
--- a/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
+++ b/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
@@ -67,7 +67,7 @@ def compare_reactor_doe():
         solver=solver,
         tee=True,
         get_labeled_model_args=None,
-        #logger_level=logging.ERROR,
+        # logger_level=logging.ERROR,
         _Cholesky_option=True,
         _only_compute_fim_lower=True,
     )
@@ -117,13 +117,13 @@ def compare_reactor_doe():
         solver=solver,
         tee=True,
         get_labeled_model_args=None,
-        #logger_level=logging.ERROR,
+        # logger_level=logging.ERROR,
         _Cholesky_option=True,
         _only_compute_fim_lower=True,
     )
 
     doe_obj_grey_box.run_doe()
-    # Print out a results summary                                                                                                                      
+    # Print out a results summary
     print("Optimal experiment values with grey-box: ")
     print(
         "\tInitial concentration: {:.2f}".format(
@@ -135,13 +135,21 @@ def compare_reactor_doe():
             *doe_obj_grey_box.results["Experiment Design"][1:]
         )
     )
-    print("FIM at optimal design with grey-box:\n {}".format(np.array(doe_obj_grey_box.results["FIM"])))
+    print(
+        "FIM at optimal design with grey-box:\n {}".format(
+            np.array(doe_obj_grey_box.results["FIM"])
+        )
+    )
     print(
         "Objective value at optimal design with grey-box: {:.2f}".format(
             pyo.value(doe_obj_grey_box.model.objective)
         )
     )
-    print("Raw logdet: {:.2f}".format(np.log10(np.linalg.det(np.array(doe_obj_grey_box.results["FIM"])))))
+    print(
+        "Raw logdet: {:.2f}".format(
+            np.log10(np.linalg.det(np.array(doe_obj_grey_box.results["FIM"])))
+        )
+    )
 
     print(doe_obj_grey_box.results["Experiment Design Names"])
 
@@ -166,6 +174,6 @@ def compare_reactor_doe():
 
     print(doe_obj.results["Experiment Design Names"])
 
-    
+
 if __name__ == "__main__":
     compare_reactor_doe()
diff --git a/pyomo/contrib/doe/examples/grey_box_E_opt.py b/pyomo/contrib/doe/examples/grey_box_E_opt.py
index b0bf5e3aee9..f4a26e57337 100644
--- a/pyomo/contrib/doe/examples/grey_box_E_opt.py
+++ b/pyomo/contrib/doe/examples/grey_box_E_opt.py
@@ -67,13 +67,13 @@ def compare_reactor_doe():
         solver=solver,
         tee=True,
         get_labeled_model_args=None,
-        #logger_level=logging.ERROR,
+        # logger_level=logging.ERROR,
         _Cholesky_option=True,
         _only_compute_fim_lower=True,
     )
 
     doe_obj_grey_box.run_doe()
-    # Print out a results summary                                                                                                                      
+    # Print out a results summary
     print("Optimal experiment values with grey-box: ")
     print(
         "\tInitial concentration: {:.2f}".format(
@@ -85,16 +85,24 @@ def compare_reactor_doe():
             *doe_obj_grey_box.results["Experiment Design"][1:]
         )
     )
-    print("FIM at optimal design with grey-box:\n {}".format(np.array(doe_obj_grey_box.results["FIM"])))
+    print(
+        "FIM at optimal design with grey-box:\n {}".format(
+            np.array(doe_obj_grey_box.results["FIM"])
+        )
+    )
     print(
         "Objective value at optimal design with grey-box: {:.2f}".format(
             pyo.value(doe_obj_grey_box.model.objective)
         )
     )
-    print("Raw logdet: {:.2f}".format(np.log10(np.linalg.det(np.array(doe_obj_grey_box.results["FIM"])))))
+    print(
+        "Raw logdet: {:.2f}".format(
+            np.log10(np.linalg.det(np.array(doe_obj_grey_box.results["FIM"])))
+        )
+    )
 
     print(doe_obj_grey_box.results["Experiment Design Names"])
 
-    
+
 if __name__ == "__main__":
     compare_reactor_doe()
diff --git a/pyomo/contrib/doe/examples/grey_box_ME_opt.py b/pyomo/contrib/doe/examples/grey_box_ME_opt.py
index 9a0665d9c9a..27bb6970433 100644
--- a/pyomo/contrib/doe/examples/grey_box_ME_opt.py
+++ b/pyomo/contrib/doe/examples/grey_box_ME_opt.py
@@ -67,13 +67,13 @@ def compare_reactor_doe():
         solver=solver,
         tee=True,
         get_labeled_model_args=None,
-        #logger_level=logging.ERROR,
+        # logger_level=logging.ERROR,
         _Cholesky_option=True,
         _only_compute_fim_lower=True,
     )
 
     doe_obj_grey_box.run_doe()
-    # Print out a results summary                                                                                                                      
+    # Print out a results summary
     print("Optimal experiment values with grey-box: ")
     print(
         "\tInitial concentration: {:.2f}".format(
@@ -85,16 +85,24 @@ def compare_reactor_doe():
             *doe_obj_grey_box.results["Experiment Design"][1:]
         )
     )
-    print("FIM at optimal design with grey-box:\n {}".format(np.array(doe_obj_grey_box.results["FIM"])))
+    print(
+        "FIM at optimal design with grey-box:\n {}".format(
+            np.array(doe_obj_grey_box.results["FIM"])
+        )
+    )
     print(
         "Objective value at optimal design with grey-box: {:.2f}".format(
             pyo.value(doe_obj_grey_box.model.objective)
         )
     )
-    print("Raw logdet: {:.2f}".format(np.log10(np.linalg.det(np.array(doe_obj_grey_box.results["FIM"])))))
+    print(
+        "Raw logdet: {:.2f}".format(
+            np.log10(np.linalg.det(np.array(doe_obj_grey_box.results["FIM"])))
+        )
+    )
 
     print(doe_obj_grey_box.results["Experiment Design Names"])
 
-    
+
 if __name__ == "__main__":
     compare_reactor_doe()
diff --git a/pyomo/contrib/doe/examples/grey_box_test.py b/pyomo/contrib/doe/examples/grey_box_test.py
index 26109f13ff6..2bac1ef3451 100644
--- a/pyomo/contrib/doe/examples/grey_box_test.py
+++ b/pyomo/contrib/doe/examples/grey_box_test.py
@@ -1,7 +1,10 @@
 import numpy as np
 import pyomo.environ as pyo
 from scipy.sparse import coo_matrix
-from pyomo.contrib.pynumero.interfaces.external_grey_box import ExternalGreyBoxModel, ExternalGreyBoxBlock
+from pyomo.contrib.pynumero.interfaces.external_grey_box import (
+    ExternalGreyBoxModel,
+    ExternalGreyBoxBlock,
+)
 
 import inspect
 from pathlib import Path
@@ -13,6 +16,7 @@
 except:
     print("No stack()[1]...")
 
+
 class LogDetModel(ExternalGreyBoxModel):
     def __init__(
         self,
@@ -29,7 +33,7 @@ def __init__(
         n_parameters: int
             Number of parameters in the model. The square symmetric matrix is of shape n_parameters*n_parameters
         initial_fim: dict
-            key: tuple (i,j) where i, j are the row, column number of FIM. value: FIM[i,j] 
+            key: tuple (i,j) where i, j are the row, column number of FIM. value: FIM[i,j]
             Initial value of the matrix. If None, the identity matrix is used.
         use_exact_derivatives: bool
             If True, the exact derivatives are used.
@@ -77,9 +81,9 @@ def input_names(self):
         ------
         input_name_list: a list of the names of inputs
         """
-        #trash = input(str(inspect.stack()[0][3]))
+        # trash = input(str(inspect.stack()[0][3]))
 
-        # store the input names as a tuple 
+        # store the input names as a tuple
         input_name_list = []
         # loop over parameters
         for i in range(self.n_parameters):
@@ -92,12 +96,12 @@ def input_names(self):
     def equality_constraint_names(self):
         """Return the names of the equality constraints."""
         # no equality constraints
-        #trash = input(str(inspect.stack()[0][3]))
+        # trash = input(str(inspect.stack()[0][3]))
         return []
 
     def output_names(self):
         """Return the names of the outputs."""
-        #trash = input(str(inspect.stack()[0][3]))
+        # trash = input(str(inspect.stack()[0][3]))
         return ["log_det"]
 
     def set_output_constraint_multipliers(self, output_con_multiplier_values):
@@ -108,7 +112,7 @@ def set_output_constraint_multipliers(self, output_con_multiplier_values):
         ---------
         output_con_multiplier_values: a scalar number for the output constraint multipliers
         """
-        #trash = input(str(inspect.stack()[0][3]))
+        # trash = input(str(inspect.stack()[0][3]))
 
         # because we only have one output constraint, the length is 1
         if len(output_con_multiplier_values) != 1:
@@ -127,7 +131,7 @@ def finalize_block_construction(self, pyomo_block):
         """
         # ele_to_order map the input position in FIM, like (a,b), to its flattend index
         # for e.g., ele_to_order[(0,0)] = 0
-        #trash = input(str(inspect.stack()[0][3]))
+        # trash = input(str(inspect.stack()[0][3]))
 
         ele_to_order = {}
         count = 0
@@ -167,17 +171,17 @@ def finalize_block_construction(self, pyomo_block):
     def set_input_values(self, input_values):
         """
         Set the values of the inputs.
-        This function refers to the notebook: 
+        This function refers to the notebook:
         https://colab.research.google.com/drive/1VplaeOTes87oSznboZXoz-q5W6gKJ9zZ?usp=sharing
 
         Arguments
         ---------
         input_values: input initial values
         """
-        # see the colab link in the doc string for why this should be a list 
+        # see the colab link in the doc string for why this should be a list
         self._input_values = list(input_values)
 
-        #trash = input(str(inspect.stack()[0][3]))
+        # trash = input(str(inspect.stack()[0][3]))
 
     def evaluate_equality_constraints(self):
         """Evaluate the equality constraints.
@@ -191,14 +195,14 @@ def evaluate_outputs(self):
         """
         Evaluate the output of the model.
         We call numpy here to compute the logdet of FIM. slogdet is used to avoid ill-conditioning issue
-        This function refers to the notebook: 
+        This function refers to the notebook:
         https://colab.research.google.com/drive/1VplaeOTes87oSznboZXoz-q5W6gKJ9zZ?usp=sharing
 
         Return
         ------
         logdet: a one-element numpy array, containing the log det value as float
         """
-        #trash = input(str(inspect.stack()[0][3]))
+        # trash = input(str(inspect.stack()[0][3]))
 
         # form matrix as a list of lists
         M = self._extract_and_assemble_fim()
@@ -219,7 +223,7 @@ def evaluate_outputs(self):
 
     def evaluate_jacobian_equality_constraints(self):
         """Evaluate the Jacobian of the equality constraints."""
-        #trash = input(str(inspect.stack()[0][3]))
+        # trash = input(str(inspect.stack()[0][3]))
         return None
 
     def _extract_and_assemble_fim(self):
@@ -230,7 +234,7 @@ def _extract_and_assemble_fim(self):
         ------
         M: a numpy array containing FIM.
         """
-        #trash = input(str(inspect.stack()[0][3]))
+        # trash = input(str(inspect.stack()[0][3]))
 
         # FIM shape Np*Np
         M = np.zeros((self.n_parameters, self.n_parameters))
@@ -256,7 +260,7 @@ def evaluate_jacobian_outputs(self):
         A sparse matrix, containing the first order gradient of the OBJ, in the shape [1,N_input]
         where N_input is the No. of off-diagonal elements//2 + Np
         """
-        #trash = input(str(inspect.stack()[0][3]))
+        # trash = input(str(inspect.stack()[0][3]))
 
         if self._use_exact_derivatives:
             M = self._extract_and_assemble_fim()
@@ -284,7 +288,7 @@ def evaluate_jacobian_outputs(self):
                         row[order], col[order], data[order] = (0, order, 2 * Minv[i, j])
             # sparse matrix
             return coo_matrix((data, (row, col)), shape=(1, self.num_input))
-        
+
 
 # import idaes
 
@@ -296,11 +300,11 @@ def evaluate_jacobian_outputs(self):
 print('Made base model.')
 
 ex_model = LogDetModel(
-            n_parameters=2,
-            initial_fim=None,
-            #initial_fim=np.ones((2, 2)),
-            print_level=1,
-        )
+    n_parameters=2,
+    initial_fim=None,
+    # initial_fim=np.ones((2, 2)),
+    print_level=1,
+)
 
 print('Added logdet model')
 m.egb = ExternalGreyBoxBlock(external_model=ex_model)
@@ -308,10 +312,10 @@ def evaluate_jacobian_outputs(self):
 print('Added as external grey box.')
 
 # constraining outputs
-m.M_con1 = pyo.Constraint(expr=(m.M[(0,0)] == m.egb.inputs[(0,0)]))
-m.M_con2 = pyo.Constraint(expr=(m.M[(0,1)] == m.egb.inputs[(0,1)]))
-m.M_con3 = pyo.Constraint(expr=(m.M[(1,1)] == m.egb.inputs[(1,1)]))
-m.M_con4 = pyo.Constraint(expr=(m.M[(1,0)] == m.M[(0,1)]))
+m.M_con1 = pyo.Constraint(expr=(m.M[(0, 0)] == m.egb.inputs[(0, 0)]))
+m.M_con2 = pyo.Constraint(expr=(m.M[(0, 1)] == m.egb.inputs[(0, 1)]))
+m.M_con3 = pyo.Constraint(expr=(m.M[(1, 1)] == m.egb.inputs[(1, 1)]))
+m.M_con4 = pyo.Constraint(expr=(m.M[(1, 0)] == m.M[(0, 1)]))
 
 print('Added constraints on symmetry for FIM.')
 
@@ -323,11 +327,11 @@ def evaluate_jacobian_outputs(self):
 
 solver = pyo.SolverFactory("cyipopt")
 solver.config.options['hessian_approximation'] = 'limited-memory'
-#solver.config.options['mu_strategy'] = 'monotone'
-#solver.config.options['linear_solver'] = 'ma27'
+# solver.config.options['mu_strategy'] = 'monotone'
+# solver.config.options['linear_solver'] = 'ma27'
 
 solver.solve(m, tee=True)
 
 m.M.pprint()
 
-#m.pprint()
+# m.pprint()
diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index bd76f9b1c11..c884587744f 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -30,9 +30,7 @@
 import logging
 from scipy.sparse import coo_matrix
 
-from pyomo.common.dependencies import (
-    numpy as np,
-)
+from pyomo.common.dependencies import numpy as np
 
 from pyomo.contrib.pynumero.interfaces.external_grey_box import ExternalGreyBoxModel
 
@@ -40,12 +38,7 @@
 
 
 class FIMExternalGreyBox(ExternalGreyBoxModel):
-    def __init__(
-            self,
-            doe_object,
-            objective_option="determinant",
-            logger_level=None,
-    ):
+    def __init__(self, doe_object, objective_option="determinant", logger_level=None):
         """
         Grey box model for metrics on the FIM. This methodology reduces numerical complexity for the
         computation of FIM metrics related to eigenvalue decomposition.
@@ -53,12 +46,12 @@ def __init__(
         Parameters
         ----------
         doe_object:
-           Design of Experiments object that contains a built model (with sensitivity matrix, Q, and 
+           Design of Experiments object that contains a built model (with sensitivity matrix, Q, and
            fisher information matrix, FIM). The external grey box model will utilize elements of the
-           doe_object's model to build the FIM metric with consistent naming. 
+           doe_object's model to build the FIM metric with consistent naming.
         obj_option:
            String representation of the objective option. Current available option is ``determinant``.
-           Other options that are planned to be implemented soon are ``minimum_eig`` (E-optimality), 
+           Other options that are planned to be implemented soon are ``minimum_eig`` (E-optimality),
            and ``condition_number`` (modified E-optimality). default option is ``determinant``
         logger_level:
            logging level to be specified if different from doe_object's logging level. default value
@@ -67,17 +60,21 @@ def __init__(
         """
 
         if doe_object is None:
-            raise ValueError("DoE Object must be provided to build external grey box of the FIM.")
+            raise ValueError(
+                "DoE Object must be provided to build external grey box of the FIM."
+            )
 
         self.doe_object = doe_object
 
         # Grab parameter list from the doe_object model
         self._param_names = [i for i in self.doe_object.model.parameter_names]
-        
+
         # Check if the doe_object has model components that are required
         # TODO: add checks for the model --> doe_object.model needs FIM; all other checks should
         #       have been satisfied before the FIM is created. Can add check for unknown_parameters...
-        self.objective_option = objective_option  # Add failsafe to make sure this is ObjectiveLib object?
+        self.objective_option = (
+            objective_option  # Add failsafe to make sure this is ObjectiveLib object?
+        )
         # Will anyone ever call this without calling DoE? --> intended to be no; but maybe more utility?
 
         # Create logger for FIM egb object
@@ -92,10 +89,11 @@ def __init__(
         # Set initial values for inputs
         # Need a mask structure
         self._masking_matrix = np.tril(np.ones_like(self.doe_object.fim_initial))
-        #self._input_values = np.asarray(self.doe_object.fim_initial.flatten(), dtype=np.float64)
-        self._input_values = np.asarray(self.doe_object.fim_initial[self._masking_matrix > 0], dtype=np.float64)
-        #print(self._input_values)
-    
+        # self._input_values = np.asarray(self.doe_object.fim_initial.flatten(), dtype=np.float64)
+        self._input_values = np.asarray(
+            self.doe_object.fim_initial[self._masking_matrix > 0], dtype=np.float64
+        )
+        # print(self._input_values)
 
     def _get_FIM(self):
         # Grabs the current FIM subject
@@ -112,14 +110,15 @@ def _get_FIM(self):
 
         return current_FIM
 
-    
     def input_names(self):
         # Cartesian product gives us matrix indicies flattened in row-first format
         # Can use itertools.combinations(self._param_names, 2) with added
         # diagonal elements, or do double for loops if we switch to upper triangular
         input_names_list = list(itertools.product(self._param_names, self._param_names))
-        input_names_list = [(self._param_names[i[0]], self._param_names[i[1] - 1]) 
-                            for i in itertools.combinations(range(len(self._param_names) + 1), 2)]
+        input_names_list = [
+            (self._param_names[i[0]], self._param_names[i[1] - 1])
+            for i in itertools.combinations(range(len(self._param_names) + 1), 2)
+        ]
         return input_names_list
 
     def equality_constraint_names(self):
@@ -132,18 +131,19 @@ def output_names(self):
         # the ObjectiveLib Enum object, which should have an associated
         # name for the objective function at all times.
         from pyomo.contrib.doe import ObjectiveLib
+
         if self.objective_option == ObjectiveLib.determinant:
             obj_name = "log10-D-opt"
         elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
             obj_name = "E-opt"
         elif self.objective_option == ObjectiveLib.condition_number:
             obj_name = "ME-opt"
-        return [obj_name, ]
+        return [obj_name]
 
     def set_input_values(self, input_values):
         # Set initial values to be flattened initial FIM (aligns with input names)
         np.copyto(self._input_values, input_values)
-        #self._input_values = list(self.doe_object.fim_initial.flatten())
+        # self._input_values = list(self.doe_object.fim_initial.flatten())
 
     def evaluate_equality_constraints(self):
         # ToDo: are there any objectives that will have constraints?
@@ -154,10 +154,13 @@ def evaluate_outputs(self):
         # ObjectiveLib type.
         current_FIM = self._get_FIM()
 
-        M = np.asarray(current_FIM, dtype=np.float64).reshape(len(self._param_names), len(self._param_names))
-        
+        M = np.asarray(current_FIM, dtype=np.float64).reshape(
+            len(self._param_names), len(self._param_names)
+        )
+
         # Change objective value based on ObjectiveLib type.
         from pyomo.contrib.doe import ObjectiveLib
+
         if self.objective_option == ObjectiveLib.determinant:
             (sign, logdet) = np.linalg.slogdet(M)
             obj_value = logdet
@@ -167,8 +170,8 @@ def evaluate_outputs(self):
         elif self.objective_option == ObjectiveLib.condition_number:
             eig, _ = np.linalg.eig(M)
             obj_value = np.max(eig) / np.min(eig)
-        
-        return np.asarray([obj_value, ], dtype=np.float64)
+
+        return np.asarray([obj_value], dtype=np.float64)
 
     def finalize_block_construction(self, pyomo_block):
         # Set bounds on the inputs/outputs
@@ -181,6 +184,7 @@ def finalize_block_construction(self, pyomo_block):
 
         # Initialize log_determinant value
         from pyomo.contrib.doe import ObjectiveLib
+
         if self.objective_option == ObjectiveLib.determinant:
             pyomo_block.outputs["log10-D-opt"] = 0
         elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
@@ -193,35 +197,38 @@ def evaluate_jacobian_equality_constraints(self):
 
         # Returns coo_matrix of the correct shape
         return None
-        
+
     def evaluate_jacobian_outputs(self):
         # Compute the jacobian of the objective function with
         # respect to the fisher information matrix. Then return
         # a coo_matrix that aligns with what IPOPT will expect.
         #
         # ToDo: there will be significant bookkeeping for more
-        # complicated objective functions and the Hessian        
+        # complicated objective functions and the Hessian
         current_FIM = self._get_FIM()
-        M = np.asarray(current_FIM, dtype=np.float64).reshape(len(self._param_names), len(self._param_names))
-        
+        M = np.asarray(current_FIM, dtype=np.float64).reshape(
+            len(self._param_names), len(self._param_names)
+        )
+
         # May remove this warning. If so, we
         # should put the eigenvalue computation
         # within the eigenvalue-dependent
         # objective options...
         eig_vals, eig_vecs = np.linalg.eig(M)
-        #print("Conditon number:")
-        #print(np.linalg.cond(M))
+        # print("Conditon number:")
+        # print(np.linalg.cond(M))
         if min(eig_vals) <= 1:
             pass
             print("Warning: {:0.6f}".format(min(eig_vals)))
 
         from pyomo.contrib.doe import ObjectiveLib
+
         if self.objective_option == ObjectiveLib.determinant:
             Minv = np.linalg.pinv(M)
             # Derivative formula derived using tensor
             # calculus. Add reference to pyomo.DoE 2.0
             # manuscript S.I.
-            jac_M = 0.5*(Minv + Minv.transpose())
+            jac_M = 0.5 * (Minv + Minv.transpose())
         elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
             # Obtain minimum eigenvalue location
             min_eig_loc = np.argmin(eig_vals)
@@ -232,7 +239,7 @@ def evaluate_jacobian_outputs(self):
             # use matrix operations later in
             # the code.
             min_eig_vec = np.array([eig_vecs[:, min_eig_loc]])
-        
+
             # Calculate the derivative matrix.
             # This is the expansion product of
             # the eigenvector we grabbed in
@@ -269,8 +276,11 @@ def evaluate_jacobian_outputs(self):
             safe_cond_number = max_eig / (min_eig + np.sign(min_eig) * min_eig_epsilon)
 
             # Combining the expression
-            jac_M = 1 / (min_eig + np.sign(min_eig) * min_eig_epsilon) * (max_eig_term - safe_cond_number * min_eig_term)
-
+            jac_M = (
+                1
+                / (min_eig + np.sign(min_eig) * min_eig_epsilon)
+                * (max_eig_term - safe_cond_number * min_eig_term)
+            )
 
         # Filter jac_M using the
         # masking matrix
@@ -289,33 +299,40 @@ def evaluate_jacobian_outputs(self):
 
         # # Need to be flat?
         # M_cols = np.arange(len(jac_M.flatten()))
-        
+
         # Returns coo_matrix of the correct shape
-        #print(coo_matrix((jac_M.flatten(), (M_rows, M_cols)), shape=(1, len(jac_M.flatten()))))
-        return coo_matrix((jac_M.flatten(), (M_rows, M_cols)), shape=(1, len(jac_M.flatten())))
+        # print(coo_matrix((jac_M.flatten(), (M_rows, M_cols)), shape=(1, len(jac_M.flatten()))))
+        return coo_matrix(
+            (jac_M.flatten(), (M_rows, M_cols)), shape=(1, len(jac_M.flatten()))
+        )
 
     # Beyond here is for Hessian information
     def set_equality_constraint_multipliers(self, eq_con_multiplier_values):
         # ToDo: Do any objectives require constraints?
         # Assert lengths match
-        self._eq_con_mult_values = np.asarray(eq_con_multiplier_values, dtype=np.float64)
+        self._eq_con_mult_values = np.asarray(
+            eq_con_multiplier_values, dtype=np.float64
+        )
 
     def set_output_constraint_multipliers(self, output_con_multiplier_values):
         # ToDo: Do any objectives require constraints?
         # Assert length matches
-        self._output_con_mult_values = np.asarray(output_con_multiplier_values, dtype=np.float64)
+        self._output_con_mult_values = np.asarray(
+            output_con_multiplier_values, dtype=np.float64
+        )
+
 
 #    def evaluate_hessian_equality_constraints(self):
-        # ToDo: Do any objectives require constraints?
+# ToDo: Do any objectives require constraints?
 
-        # Returns coo_matrix of the correct shape
+# Returns coo_matrix of the correct shape
 #        return None
 
 #    def evaluate_hessian_outputs(self):
-        # ToDo: Add for objectives where we can define the Hessian
-        #
-        # ToDo: significant bookkeeping if the hessian's require vectorized
-        # operations. Just need mapping that works well and we are good.
-        
-        # Returns coo_matrix of the correct shape
+# ToDo: Add for objectives where we can define the Hessian
+#
+# ToDo: significant bookkeeping if the hessian's require vectorized
+# operations. Just need mapping that works well and we are good.
+
+# Returns coo_matrix of the correct shape
 #        return None

From 6e0906a2b16059a2027ed19f3626d6d0b8395daf Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 27 Mar 2025 10:20:58 -0400
Subject: [PATCH 018/143] Trying to fix bugs

---
 pyomo/contrib/doe/doe.py                     | 10 ++++++----
 pyomo/contrib/doe/examples/grey_box_E_opt.py |  5 +++++
 pyomo/contrib/doe/grey_box_utilities.py      | 17 +++++++++++------
 3 files changed, 22 insertions(+), 10 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index f32ef2906e8..b469c4d2ee3 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -306,10 +306,12 @@ def FIM_egb_cons(m, p1, p2):
                 p2: parameter 2
 
                 """
-                if list(model.parameter_names).index(p1) <= list(
+                # Using upper triangular egb to
+                # use easier naming conventions.
+                if list(model.parameter_names).index(p1) >= list(
                     model.parameter_names
                 ).index(p2):
-                    return model.fim[(p1, p2)] == m.egb_fim_block.inputs[(p1, p2)]
+                    return model.fim[(p1, p2)] == m.egb_fim_block.inputs[(p2, p1)]
                 else:
                     return pyo.Constraint.Skip
 
@@ -388,10 +390,10 @@ def FIM_egb_cons(m, p1, p2):
             # Initialize grey box inputs to be fim values currently
             for i in model.parameter_names:
                 for j in model.parameter_names:
-                    if list(model.parameter_names).index(i) <= list(
+                    if list(model.parameter_names).index(i) >= list(
                         model.parameter_names
                     ).index(j):
-                        model.obj_cons.egb_fim_block.inputs[(i, j)].set_value(
+                        model.obj_cons.egb_fim_block.inputs[(j, i)].set_value(
                             pyo.value(model.fim[(i, j)])
                         )
 
diff --git a/pyomo/contrib/doe/examples/grey_box_E_opt.py b/pyomo/contrib/doe/examples/grey_box_E_opt.py
index f4a26e57337..c0b4d3a8e10 100644
--- a/pyomo/contrib/doe/examples/grey_box_E_opt.py
+++ b/pyomo/contrib/doe/examples/grey_box_E_opt.py
@@ -95,6 +95,11 @@ def compare_reactor_doe():
             pyo.value(doe_obj_grey_box.model.objective)
         )
     )
+    print(
+        "E-opt at optimal design with grey-box: {:.2f}".format(
+            pyo.value(doe_obj_grey_box.results["log10 E-opt"])
+        )
+    )
     print(
         "Raw logdet: {:.2f}".format(
             np.log10(np.linalg.det(np.array(doe_obj_grey_box.results["FIM"])))
diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index c884587744f..6609acf0d2c 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -101,12 +101,15 @@ def _get_FIM(self):
         # This function currently assumes
         # that we use a lower triangular
         # FIM.
-        lowt_FIM = self._input_values
+        upt_FIM = self._input_values
 
         # Create FIM in the correct way
-        current_FIM = np.ones_like(self.doe_object.fim_initial)
-        current_FIM[np.tril_indices_from(current_FIM)] = lowt_FIM
-        current_FIM[np.triu_indices_from(current_FIM)] = lowt_FIM
+        current_FIM = np.zeros_like(self.doe_object.fim_initial)
+        # Utilize upper triangular portion of FIM
+        current_FIM[np.triu_indices_from(current_FIM)] = upt_FIM
+        # Construct lower triangular using the
+        # current upper triangle minus the diagonal.
+        current_FIM += current_FIM.transpose() - np.diag(np.diag(current_FIM))
 
         return current_FIM
 
@@ -215,8 +218,10 @@ def evaluate_jacobian_outputs(self):
         # within the eigenvalue-dependent
         # objective options...
         eig_vals, eig_vecs = np.linalg.eig(M)
-        # print("Conditon number:")
-        # print(np.linalg.cond(M))
+        # TODO: Make this more formal and
+        # robust?
+        eig_vals = eig_vals.real
+        eig_vecs = eig_vecs.real
         if min(eig_vals) <= 1:
             pass
             print("Warning: {:0.6f}".format(min(eig_vals)))

From 19d8e859e76e08506e371a1d595a16d69358f08a Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 27 Mar 2025 15:20:55 -0400
Subject: [PATCH 019/143] Attempt at adding hessian for D opt

---
 pyomo/contrib/doe/doe.py                      |  18 ++-
 .../doe/examples/grey_box_D_opt_comparison.py |   8 +-
 pyomo/contrib/doe/examples/grey_box_E_opt.py  |  35 +++++-
 pyomo/contrib/doe/examples/grey_box_ME_opt.py |  36 +++++-
 .../doe/examples/grey_box_test_hessian.py     | 106 ++++++++++++++++++
 pyomo/contrib/doe/examples/reactor_example.py |  44 ++++----
 .../doe/examples/reactor_experiment.py        |   2 +
 pyomo/contrib/doe/grey_box_utilities.py       |  96 ++++++++++++----
 8 files changed, 286 insertions(+), 59 deletions(-)
 create mode 100644 pyomo/contrib/doe/examples/grey_box_test_hessian.py

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index b469c4d2ee3..bf2bcca86a8 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -195,8 +195,8 @@ def __init__(
         # if not given, use default solver
         else:
             solver = pyo.SolverFactory("ipopt")
-            # solver.options["linear_solver"] = "ma57"
-            solver.options["linear_solver"] = "MUMPS"
+            solver.options["linear_solver"] = "ma57"
+            # solver.options["linear_solver"] = "MUMPS"
             solver.options["halt_on_ampl_error"] = "yes"
             solver.options["max_iter"] = 3000
             solver.options["tol"] = 1e-4
@@ -211,8 +211,8 @@ def __init__(
             grey_box_solver = pyo.SolverFactory("cyipopt")
             grey_box_solver.config.options['hessian_approximation'] = 'limited-memory'
             # grey_box_solver.config.options["linear_solver"] = "ma57"
-            grey_box_solver.config.options['max_iter'] = 3000
-            grey_box_solver.config.options['tol'] = 1e-5
+            grey_box_solver.config.options['max_iter'] = 500
+            grey_box_solver.config.options['tol'] = 1e-4
             # grey_box_solver.config.options['mu_strategy'] = "monotone"
 
             self.grey_box_solver = grey_box_solver
@@ -396,6 +396,16 @@ def FIM_egb_cons(m, p1, p2):
                         model.obj_cons.egb_fim_block.inputs[(j, i)].set_value(
                             pyo.value(model.fim[(i, j)])
                         )
+            # Set objective value
+            if self.objective_option == ObjectiveLib.determinant:
+                det_val = np.linalg.det(np.array(self.get_FIM()))
+                model.obj_cons.egb_fim_block.outputs["log10-D-opt"].set_value(np.log10(det_val))
+            elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
+                eig, _ = np.linalg.eig(np.array(self.get_FIM()))
+                model.obj_cons.egb_fim_block.outputs["E-opt"].set_value(np.min(eig))
+            elif self.objective_option == ObjectiveLib.condition_number:
+                cond_number = np.linalg.cond(np.array(self.get_FIM()))
+                model.obj_cons.egb_fim_block.outputs["ME-opt"].set_value(cond_number)
 
         # If the model has L, initialize it with the solved FIM
         if hasattr(model, "L"):
diff --git a/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py b/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
index 763b2620d0d..2c5ecfb7c9a 100644
--- a/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
+++ b/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
@@ -47,8 +47,8 @@ def compare_reactor_doe():
     objective_option = "determinant"
     scale_nominal_param_value = True
 
-    solver = pyo.SolverFactory("ipopt")
-    solver.options["linear_solver"] = "mumps"
+    # solver = pyo.SolverFactory("ipopt")
+    # solver.options["linear_solver"] = "mumps"
     # Create the DesignOfExperiments object
     # We will not be passing any prior information in this example
     # and allow the experiment object and the DesignOfExperiments
@@ -64,7 +64,7 @@ def compare_reactor_doe():
         jac_initial=None,
         fim_initial=None,
         L_diagonal_lower_bound=1e-7,
-        solver=solver,
+        solver=None,
         tee=True,
         get_labeled_model_args=None,
         # logger_level=logging.ERROR,
@@ -114,7 +114,7 @@ def compare_reactor_doe():
         jac_initial=None,
         fim_initial=None,
         L_diagonal_lower_bound=1e-7,
-        solver=solver,
+        solver=None,
         tee=True,
         get_labeled_model_args=None,
         # logger_level=logging.ERROR,
diff --git a/pyomo/contrib/doe/examples/grey_box_E_opt.py b/pyomo/contrib/doe/examples/grey_box_E_opt.py
index c0b4d3a8e10..4cf58f5cb67 100644
--- a/pyomo/contrib/doe/examples/grey_box_E_opt.py
+++ b/pyomo/contrib/doe/examples/grey_box_E_opt.py
@@ -50,6 +50,30 @@ def compare_reactor_doe():
     solver = pyo.SolverFactory("ipopt")
     solver.options["linear_solver"] = "mumps"
 
+    # DoE object to compute FIM prior
+    # doe_obj = DesignOfExperiments(
+    #     experiment,
+    #     fd_formula=fd_formula,
+    #     step=step_size,
+    #     objective_option=objective_option,
+    #     use_grey_box_objective=True,  # New object with grey box set to True
+    #     scale_constant_value=1,
+    #     scale_nominal_param_value=scale_nominal_param_value,
+    #     prior_FIM=None,
+    #     jac_initial=None,
+    #     fim_initial=None,
+    #     L_diagonal_lower_bound=1e-7,
+    #     solver=solver,
+    #     tee=True,
+    #     get_labeled_model_args=None,
+    #     # logger_level=logging.ERROR,
+    #     _Cholesky_option=True,
+    #     _only_compute_fim_lower=True,
+    # )
+
+    # prior_FIM = doe_obj.compute_FIM(method="sequential")
+    prior_FIM = None
+
     # Begin optimal grey box DoE
     ############################
     doe_obj_grey_box = DesignOfExperiments(
@@ -60,7 +84,7 @@ def compare_reactor_doe():
         use_grey_box_objective=True,  # New object with grey box set to True
         scale_constant_value=1,
         scale_nominal_param_value=scale_nominal_param_value,
-        prior_FIM=None,
+        prior_FIM=prior_FIM,
         jac_initial=None,
         fim_initial=None,
         L_diagonal_lower_bound=1e-7,
@@ -81,10 +105,15 @@ def compare_reactor_doe():
         )
     )
     print(
-        ("\tTemperature values: [" + "{:.2f}, " * 8 + "{:.2f}]").format(
-            *doe_obj_grey_box.results["Experiment Design"][1:]
+        ("\tTemperature values: [{:.2f}]").format(
+            doe_obj_grey_box.results["Experiment Design"][1]
         )
     )
+    # print(
+    #     ("\tTemperature values: [" + "{:.2f}, " * 8 + "{:.2f}]").format(
+    #         *doe_obj_grey_box.results["Experiment Design"][1:]
+    #     )
+    # )
     print(
         "FIM at optimal design with grey-box:\n {}".format(
             np.array(doe_obj_grey_box.results["FIM"])
diff --git a/pyomo/contrib/doe/examples/grey_box_ME_opt.py b/pyomo/contrib/doe/examples/grey_box_ME_opt.py
index 27bb6970433..accc1362d31 100644
--- a/pyomo/contrib/doe/examples/grey_box_ME_opt.py
+++ b/pyomo/contrib/doe/examples/grey_box_ME_opt.py
@@ -50,6 +50,30 @@ def compare_reactor_doe():
     solver = pyo.SolverFactory("ipopt")
     solver.options["linear_solver"] = "mumps"
 
+    # DoE object to compute FIM prior
+    doe_obj = DesignOfExperiments(
+        experiment,
+        fd_formula=fd_formula,
+        step=step_size,
+        objective_option=objective_option,
+        use_grey_box_objective=True,  # New object with grey box set to True
+        scale_constant_value=1,
+        scale_nominal_param_value=scale_nominal_param_value,
+        prior_FIM=None,
+        jac_initial=None,
+        fim_initial=None,
+        L_diagonal_lower_bound=1e-7,
+        solver=solver,
+        tee=True,
+        get_labeled_model_args=None,
+        # logger_level=logging.ERROR,
+        _Cholesky_option=True,
+        _only_compute_fim_lower=True,
+    )
+
+    prior_FIM = doe_obj.compute_FIM(method="sequential")
+    # prior_FIM = None
+
     # Begin optimal grey box DoE
     ############################
     doe_obj_grey_box = DesignOfExperiments(
@@ -81,10 +105,15 @@ def compare_reactor_doe():
         )
     )
     print(
-        ("\tTemperature values: [" + "{:.2f}, " * 8 + "{:.2f}]").format(
-            *doe_obj_grey_box.results["Experiment Design"][1:]
+        ("\tTemperature values: [{:.2f}]").format(
+            doe_obj_grey_box.results["Experiment Design"][1]
         )
     )
+    # print(
+    #     ("\tTemperature values: [" + "{:.2f}, " * 8 + "{:.2f}]").format(
+    #         *doe_obj_grey_box.results["Experiment Design"][1:]
+    #     )
+    # )
     print(
         "FIM at optimal design with grey-box:\n {}".format(
             np.array(doe_obj_grey_box.results["FIM"])
@@ -100,6 +129,9 @@ def compare_reactor_doe():
             np.log10(np.linalg.det(np.array(doe_obj_grey_box.results["FIM"])))
         )
     )
+    print("Eigenvalues")
+    eig, _ = np.linalg.eig(np.array(doe_obj_grey_box.results["FIM"]))
+    print(np.max(eig), np.min(eig))
 
     print(doe_obj_grey_box.results["Experiment Design Names"])
 
diff --git a/pyomo/contrib/doe/examples/grey_box_test_hessian.py b/pyomo/contrib/doe/examples/grey_box_test_hessian.py
new file mode 100644
index 00000000000..5f3ff81b4a6
--- /dev/null
+++ b/pyomo/contrib/doe/examples/grey_box_test_hessian.py
@@ -0,0 +1,106 @@
+#  ___________________________________________________________________________
+#
+#  Pyomo: Python Optimization Modeling Objects
+#  Copyright (c) 2008-2024
+#  National Technology and Engineering Solutions of Sandia, LLC
+#  Under the terms of Contract DE-NA0003525 with National Technology and
+#  Engineering Solutions of Sandia, LLC, the U.S. Government retains certain
+#  rights in this software.
+#  This software is distributed under the 3-clause BSD License.
+#  ___________________________________________________________________________
+from pyomo.common.dependencies import numpy as np
+
+from pyomo.contrib.doe.examples.reactor_experiment import ReactorExperiment
+from pyomo.contrib.doe import DesignOfExperiments
+
+import pyomo.environ as pyo
+
+import json
+import logging
+from pathlib import Path
+
+from pyomo.contrib.doe import FIMExternalGreyBox
+
+
+# Seeing if D-optimal experiment matches for both the
+# greybox objective and the algebraic objective
+def compare_reactor_doe():
+    # Read in file
+    DATA_DIR = Path(__file__).parent
+    file_path = DATA_DIR / "result.json"
+
+    with open(file_path) as f:
+        data_ex = json.load(f)
+
+    # Put temperature control time points into correct format for reactor experiment
+    data_ex["control_points"] = {
+        float(k): v for k, v in data_ex["control_points"].items()
+    }
+
+    # Create a ReactorExperiment object; data and discretization information are part
+    # of the constructor of this object
+    experiment = ReactorExperiment(data=data_ex, nfe=10, ncp=3)
+
+    # Use a central difference, with step size 1e-3
+    fd_formula = "central"
+    step_size = 1e-3
+
+    # Use the determinant objective with scaled sensitivity matrix
+    objective_option = "determinant"
+    scale_nominal_param_value = True
+
+    #solver = pyo.SolverFactory("ipopt")
+    #solver.options["linear_solver"] = "mumps"
+
+    # DoE object to compute FIM prior
+    # doe_obj = DesignOfExperiments(
+    #     experiment,
+    #     fd_formula=fd_formula,
+    #     step=step_size,
+    #     objective_option=objective_option,
+    #     use_grey_box_objective=True,  # New object with grey box set to True
+    #     scale_constant_value=1,
+    #     scale_nominal_param_value=scale_nominal_param_value,
+    #     prior_FIM=None,
+    #     jac_initial=None,
+    #     fim_initial=None,
+    #     L_diagonal_lower_bound=1e-7,
+    #     solver=solver,
+    #     tee=True,
+    #     get_labeled_model_args=None,
+    #     # logger_level=logging.ERROR,
+    #     _Cholesky_option=True,
+    #     _only_compute_fim_lower=True,
+    # )
+
+    # prior_FIM = doe_obj.compute_FIM(method="sequential")
+    prior_FIM = None
+
+    # Begin optimal grey box DoE
+    ############################
+    doe_obj = DesignOfExperiments(
+        experiment,
+        fd_formula=fd_formula,
+        step=step_size,
+        objective_option=objective_option,
+        scale_constant_value=1,
+        scale_nominal_param_value=scale_nominal_param_value,
+        prior_FIM=None,
+        jac_initial=None,
+        fim_initial=None,
+        L_diagonal_lower_bound=1e-7,
+        solver=None,
+        tee=True,
+        get_labeled_model_args=None,
+        _Cholesky_option=True,
+        _only_compute_fim_lower=True,
+    )
+
+    doe_obj.run_doe()
+
+    grey_box_check = FIMExternalGreyBox(doe_object=doe_obj, )
+    return grey_box_check, doe_obj
+
+
+if __name__ == "__main__":
+    compare_reactor_doe()
diff --git a/pyomo/contrib/doe/examples/reactor_example.py b/pyomo/contrib/doe/examples/reactor_example.py
index 6ef1cf1c453..83d995c677d 100644
--- a/pyomo/contrib/doe/examples/reactor_example.py
+++ b/pyomo/contrib/doe/examples/reactor_example.py
@@ -62,7 +62,7 @@ def run_reactor_doe():
         fim_initial=None,
         L_diagonal_lower_bound=1e-7,
         solver=None,
-        tee=False,
+        tee=True,
         get_labeled_model_args=None,
         _Cholesky_option=True,
         _only_compute_fim_lower=True,
@@ -72,27 +72,27 @@ def run_reactor_doe():
     design_ranges = {"CA[0]": [1, 5, 9], "T[0]": [300, 700, 9]}
 
     # Compute the full factorial design with the sequential FIM calculation
-    doe_obj.compute_FIM_full_factorial(design_ranges=design_ranges, method="sequential")
-
-    # Plot the results
-    doe_obj.draw_factorial_figure(
-        sensitivity_design_variables=["CA[0]", "T[0]"],
-        fixed_design_variables={
-            "T[0.125]": 300,
-            "T[0.25]": 300,
-            "T[0.375]": 300,
-            "T[0.5]": 300,
-            "T[0.625]": 300,
-            "T[0.75]": 300,
-            "T[0.875]": 300,
-            "T[1]": 300,
-        },
-        title_text="Reactor Example",
-        xlabel_text="Concentration of A (M)",
-        ylabel_text="Initial Temperature (K)",
-        figure_file_name="example_reactor_compute_FIM",
-        log_scale=False,
-    )
+    # doe_obj.compute_FIM_full_factorial(design_ranges=design_ranges, method="sequential")
+
+    # # Plot the results
+    # doe_obj.draw_factorial_figure(
+    #     sensitivity_design_variables=["CA[0]", "T[0]"],
+    #     fixed_design_variables={
+    #         "T[0.125]": 300,
+    #         "T[0.25]": 300,
+    #         "T[0.375]": 300,
+    #         "T[0.5]": 300,
+    #         "T[0.625]": 300,
+    #         "T[0.75]": 300,
+    #         "T[0.875]": 300,
+    #         "T[1]": 300,
+    #     },
+    #     title_text="Reactor Example",
+    #     xlabel_text="Concentration of A (M)",
+    #     ylabel_text="Initial Temperature (K)",
+    #     figure_file_name="example_reactor_compute_FIM",
+    #     log_scale=False,
+    # )
 
     ###########################
     # End sensitivity analysis
diff --git a/pyomo/contrib/doe/examples/reactor_experiment.py b/pyomo/contrib/doe/examples/reactor_experiment.py
index 34a67a50f95..7370244c31c 100644
--- a/pyomo/contrib/doe/examples/reactor_experiment.py
+++ b/pyomo/contrib/doe/examples/reactor_experiment.py
@@ -156,6 +156,7 @@ def finalize_model(self):
         for t in m.t:
             if t in control_points:
                 cv = control_points[t]
+                m.T[t].fix()
             m.T[t].setlb(self.data["T_bounds"][0])
             m.T[t].setub(self.data["T_bounds"][1])
             m.T[t] = cv
@@ -203,6 +204,7 @@ def label_experiment(self):
         # Add experimental input label for initial concentration
         m.experiment_inputs[m.CA[m.t.first()]] = None
         # Add experimental input label for Temperature
+        # m.experiment_inputs[m.T[m.t.first()]] = None
         m.experiment_inputs.update((m.T[t], None) for t in m.t_control)
 
         # Add unknown parameter labels
diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index 6609acf0d2c..92e09e11ab0 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -68,10 +68,14 @@ def __init__(self, doe_object, objective_option="determinant", logger_level=None
 
         # Grab parameter list from the doe_object model
         self._param_names = [i for i in self.doe_object.model.parameter_names]
+        self._n_params = len(self._param_names)
 
         # Check if the doe_object has model components that are required
         # TODO: add checks for the model --> doe_object.model needs FIM; all other checks should
         #       have been satisfied before the FIM is created. Can add check for unknown_parameters...
+        if objective_option == "determinant":
+            from pyomo.contrib.doe import ObjectiveLib
+            objective_option = ObjectiveLib(objective_option)
         self.objective_option = (
             objective_option  # Add failsafe to make sure this is ObjectiveLib object?
         )
@@ -82,7 +86,7 @@ def __init__(self, doe_object, objective_option="determinant", logger_level=None
 
         # If logger level is None, use doe_object's logger level
         if logger_level is None:
-            logger_level = doe_object.logger.getLevel()
+            logger_level = doe_object.logger.level
 
         self.logger.setLevel(level=logger_level)
 
@@ -93,6 +97,7 @@ def __init__(self, doe_object, objective_option="determinant", logger_level=None
         self._input_values = np.asarray(
             self.doe_object.fim_initial[self._masking_matrix > 0], dtype=np.float64
         )
+        self._n_inputs = len(self._input_values)
         # print(self._input_values)
 
     def _get_FIM(self):
@@ -118,10 +123,7 @@ def input_names(self):
         # Can use itertools.combinations(self._param_names, 2) with added
         # diagonal elements, or do double for loops if we switch to upper triangular
         input_names_list = list(itertools.product(self._param_names, self._param_names))
-        input_names_list = [
-            (self._param_names[i[0]], self._param_names[i[1] - 1])
-            for i in itertools.combinations(range(len(self._param_names) + 1), 2)
-        ]
+        input_names_list = list(itertools.combinations_with_replacement(self._param_names, 2))
         return input_names_list
 
     def equality_constraint_names(self):
@@ -158,7 +160,7 @@ def evaluate_outputs(self):
         current_FIM = self._get_FIM()
 
         M = np.asarray(current_FIM, dtype=np.float64).reshape(
-            len(self._param_names), len(self._param_names)
+            self._n_params, self._n_params
         )
 
         # Change objective value based on ObjectiveLib type.
@@ -173,6 +175,8 @@ def evaluate_outputs(self):
         elif self.objective_option == ObjectiveLib.condition_number:
             eig, _ = np.linalg.eig(M)
             obj_value = np.max(eig) / np.min(eig)
+        
+        # print(obj_value)
 
         return np.asarray([obj_value], dtype=np.float64)
 
@@ -210,7 +214,7 @@ def evaluate_jacobian_outputs(self):
         # complicated objective functions and the Hessian
         current_FIM = self._get_FIM()
         M = np.asarray(current_FIM, dtype=np.float64).reshape(
-            len(self._param_names), len(self._param_names)
+            self._n_params, self._n_params
         )
 
         # May remove this warning. If so, we
@@ -218,13 +222,9 @@ def evaluate_jacobian_outputs(self):
         # within the eigenvalue-dependent
         # objective options...
         eig_vals, eig_vecs = np.linalg.eig(M)
-        # TODO: Make this more formal and
-        # robust?
-        eig_vals = eig_vals.real
-        eig_vecs = eig_vecs.real
         if min(eig_vals) <= 1:
             pass
-            print("Warning: {:0.6f}".format(min(eig_vals)))
+            #print("Warning: {:0.6f}".format(min(eig_vals)))
 
         from pyomo.contrib.doe import ObjectiveLib
 
@@ -273,7 +273,7 @@ def evaluate_jacobian_outputs(self):
             min_eig_term = min_eig_vec * np.transpose(min_eig_vec)
             max_eig_term = max_eig_vec * np.transpose(max_eig_vec)
 
-            min_eig_epsilon = 1e-8
+            min_eig_epsilon = 2e-16
 
             # Computing a (hopefully) nonsingular
             # condition number for the jacobian
@@ -326,18 +326,66 @@ def set_output_constraint_multipliers(self, output_con_multiplier_values):
             output_con_multiplier_values, dtype=np.float64
         )
 
+    def evaluate_hessian_equality_constraints(self):
+        #ToDo: Do any objectives require constraints?
+        #Returns coo_matrix of the correct shape
+        return None
 
-#    def evaluate_hessian_equality_constraints(self):
-# ToDo: Do any objectives require constraints?
+    def evaluate_hessian_outputs(self, FIM=None):
+        # ToDo: significant bookkeeping if the hessian's require vectorized
+        # operations. Just need mapping that works well and we are good.
+        if FIM is None:
+            current_FIM = self._get_FIM()
+        else:
+            current_FIM = FIM
+        M = np.asarray(current_FIM, dtype=np.float64).reshape(
+            self._n_params, self._n_params
+        )
 
-# Returns coo_matrix of the correct shape
-#        return None
+        # Hessian with correct size for using only the
+        # lower (upper) triangle of the FIM
+        hess = np.zeros((self._n_inputs, self._n_inputs))
 
-#    def evaluate_hessian_outputs(self):
-# ToDo: Add for objectives where we can define the Hessian
-#
-# ToDo: significant bookkeeping if the hessian's require vectorized
-# operations. Just need mapping that works well and we are good.
+        from pyomo.contrib.doe import ObjectiveLib
+        if self.objective_option == ObjectiveLib.determinant:
+            # Grab inverse
+            Minv = np.linalg.pinv(M)
+
+            # Equation derived, shown in greybox
+            # pyomo.DoE 2.0 paper
+            # dMinv/dM(i,j,k,l) = -1/2(Minv[i, k]Minv[l, j] + 
+            #                          Minv[i, l]Minv[k, j])
+            lower_tri_inds_4D = itertools.combinations_with_replacement(range(self._n_params), 4)
+            for curr_location in lower_tri_inds_4D:
+                # For quadruples (i, j, k, l)...
+                # Row of hessian is sum from
+                # n - i + 1 to n minus i plus j
+                #
+                # Column of hessian is sum from
+                # n - k + 1 to n minus k plus l
+                i, j, k, l = curr_location
+                print(i, j, k, l)
+                row = sum(range(self._n_params - i + 1, self._n_params + 1)) - i + j
+                col = sum(range(self._n_params - k + 1, self._n_params + 1)) - k + l
+                hess[row, col] = -(1/2) * (Minv[i, k] * Minv[l, j] + Minv[i, l] * Minv[j, k])
+            
+            print(hess)
+            # Complete the full matrix
+            hess = hess.transpose()
+        elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
+            pass
+        elif self.objective_option == ObjectiveLib.condition_number:
+            pass
+        
+        # Select only lower triangular values as a flat array
+        hess_masking_matrix = np.tril(np.ones_like(hess))
+        hess_data = hess[hess_masking_matrix > 0]
+        hess_rows, hess_cols  = np.tril_indices_from(hess)
 
-# Returns coo_matrix of the correct shape
-#        return None
+        print(hess_rows)
+        print(hess_cols)
+
+        # Returns coo_matrix of the correct shape
+        return coo_matrix(
+            (hess_data, (hess_rows, hess_cols)), shape=hess.shape
+        )

From 41d18177796aefbed338d5bb9c71dedc74ed9f6b Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 3 Apr 2025 10:07:33 -0400
Subject: [PATCH 020/143] Reverted lower triangle change

Trying to get D-optimality to work without hessian first.
---
 pyomo/contrib/doe/doe.py                      |  20 ++-
 .../doe/examples/grey_box_D_opt_comparison.py |  30 +++-
 .../doe/examples/reactor_experiment.py        |   4 +-
 pyomo/contrib/doe/grey_box_utilities.py       | 161 +++++++++---------
 4 files changed, 122 insertions(+), 93 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index bf2bcca86a8..b4bcc7e49db 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -199,7 +199,7 @@ def __init__(
             # solver.options["linear_solver"] = "MUMPS"
             solver.options["halt_on_ampl_error"] = "yes"
             solver.options["max_iter"] = 3000
-            solver.options["tol"] = 1e-4
+            #solver.options["tol"] = 1e-4
             self.solver = solver
 
         self.tee = tee
@@ -209,10 +209,10 @@ def __init__(
             self.grey_box_solver = grey_box_solver
         else:
             grey_box_solver = pyo.SolverFactory("cyipopt")
-            grey_box_solver.config.options['hessian_approximation'] = 'limited-memory'
+            # grey_box_solver.config.options['hessian_approximation'] = 'limited-memory'
             # grey_box_solver.config.options["linear_solver"] = "ma57"
-            grey_box_solver.config.options['max_iter'] = 500
-            grey_box_solver.config.options['tol'] = 1e-4
+            grey_box_solver.config.options['max_iter'] = 200
+            #grey_box_solver.config.options['tol'] = 1e-4
             # grey_box_solver.config.options['mu_strategy'] = "monotone"
 
             self.grey_box_solver = grey_box_solver
@@ -313,12 +313,16 @@ def FIM_egb_cons(m, p1, p2):
                 ).index(p2):
                     return model.fim[(p1, p2)] == m.egb_fim_block.inputs[(p2, p1)]
                 else:
-                    return pyo.Constraint.Skip
+                    # return pyo.Constraint.Skip
+                    return model.fim[(p2, p1)] == m.egb_fim_block.inputs[(p2, p1)]
 
             model.obj_cons.FIM_equalities = pyo.Constraint(
                 model.parameter_names, model.parameter_names, rule=FIM_egb_cons
             )
 
+            model.obj_cons.pprint()
+            model.fim_constraint.pprint()
+
             # ToDo: Add naming convention to adjust name of objective output
             # to conincide with the ObjectiveLib type
             # ToDo: Write test for each option successfully building
@@ -396,10 +400,14 @@ def FIM_egb_cons(m, p1, p2):
                         model.obj_cons.egb_fim_block.inputs[(j, i)].set_value(
                             pyo.value(model.fim[(i, j)])
                         )
+                    else:  # REMOVE THIS IF USING LOWER TRIANGLE
+                        model.obj_cons.egb_fim_block.inputs[(j, i)].set_value(
+                            pyo.value(model.fim[(j, i)])
+                        )
             # Set objective value
             if self.objective_option == ObjectiveLib.determinant:
                 det_val = np.linalg.det(np.array(self.get_FIM()))
-                model.obj_cons.egb_fim_block.outputs["log10-D-opt"].set_value(np.log10(det_val))
+                model.obj_cons.egb_fim_block.outputs["log10-D-opt"].set_value(np.log(det_val))
             elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
                 eig, _ = np.linalg.eig(np.array(self.get_FIM()))
                 model.obj_cons.egb_fim_block.outputs["E-opt"].set_value(np.min(eig))
diff --git a/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py b/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
index 2c5ecfb7c9a..a95313007e4 100644
--- a/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
+++ b/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
@@ -83,11 +83,11 @@ def compare_reactor_doe():
             doe_obj.results["Experiment Design"][0]
         )
     )
-    print(
-        ("\tTemperature values: [" + "{:.2f}, " * 8 + "{:.2f}]").format(
-            *doe_obj.results["Experiment Design"][1:]
-        )
-    )
+    # print(
+    #     ("\tTemperature values: [" + "{:.2f}, " * 8 + "{:.2f}]").format(
+    #         *doe_obj.results["Experiment Design"][1:]
+    #     )
+    # )
     print("FIM at optimal design:\n {}".format(np.array(doe_obj.results["FIM"])))
     print(
         "Objective value at optimal design: {:.2f}".format(
@@ -130,9 +130,14 @@ def compare_reactor_doe():
             doe_obj_grey_box.results["Experiment Design"][0]
         )
     )
+    # print(
+    #     ("\tTemperature values: [" + "{:.2f}, " * 8 + "{:.2f}]").format(
+    #         *doe_obj_grey_box.results["Experiment Design"][1:]
+    #     )
+    # )
     print(
-        ("\tTemperature values: [" + "{:.2f}, " * 8 + "{:.2f}]").format(
-            *doe_obj_grey_box.results["Experiment Design"][1:]
+        ("\tTemperature values: [""{:.2f}]").format(
+            doe_obj_grey_box.results["Experiment Design"][1]
         )
     )
     print(
@@ -153,6 +158,8 @@ def compare_reactor_doe():
 
     print(doe_obj_grey_box.results["Experiment Design Names"])
 
+    print()
+
     # Print out a results summary
     print("Optimal experiment values: ")
     print(
@@ -160,9 +167,14 @@ def compare_reactor_doe():
             doe_obj.results["Experiment Design"][0]
         )
     )
+    # print(
+    #     ("\tTemperature values: [" + "{:.2f}, " * 8 + "{:.2f}]").format(
+    #         *doe_obj.results["Experiment Design"][1:]
+    #     )
+    # )
     print(
-        ("\tTemperature values: [" + "{:.2f}, " * 8 + "{:.2f}]").format(
-            *doe_obj.results["Experiment Design"][1:]
+        ("\tTemperature values: [""{:.2f}]").format(
+            doe_obj.results["Experiment Design"][1]
         )
     )
     print("FIM at optimal design:\n {}".format(np.array(doe_obj.results["FIM"])))
diff --git a/pyomo/contrib/doe/examples/reactor_experiment.py b/pyomo/contrib/doe/examples/reactor_experiment.py
index 7370244c31c..58643ea07cf 100644
--- a/pyomo/contrib/doe/examples/reactor_experiment.py
+++ b/pyomo/contrib/doe/examples/reactor_experiment.py
@@ -204,8 +204,8 @@ def label_experiment(self):
         # Add experimental input label for initial concentration
         m.experiment_inputs[m.CA[m.t.first()]] = None
         # Add experimental input label for Temperature
-        # m.experiment_inputs[m.T[m.t.first()]] = None
-        m.experiment_inputs.update((m.T[t], None) for t in m.t_control)
+        m.experiment_inputs[m.T[m.t.first()]] = None
+        # m.experiment_inputs.update((m.T[t], None) for t in m.t_control)
 
         # Add unknown parameter labels
         m.unknown_parameters = pyo.Suffix(direction=pyo.Suffix.LOCAL)
diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index 92e09e11ab0..7f789684601 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -92,11 +92,11 @@ def __init__(self, doe_object, objective_option="determinant", logger_level=None
 
         # Set initial values for inputs
         # Need a mask structure
-        self._masking_matrix = np.tril(np.ones_like(self.doe_object.fim_initial))
-        # self._input_values = np.asarray(self.doe_object.fim_initial.flatten(), dtype=np.float64)
-        self._input_values = np.asarray(
-            self.doe_object.fim_initial[self._masking_matrix > 0], dtype=np.float64
-        )
+        self._masking_matrix = np.triu(np.ones_like(self.doe_object.fim_initial))
+        self._input_values = np.asarray(self.doe_object.fim_initial.flatten(), dtype=np.float64)
+        # self._input_values = np.asarray(
+        #     self.doe_object.fim_initial[self._masking_matrix > 0], dtype=np.float64
+        # )
         self._n_inputs = len(self._input_values)
         # print(self._input_values)
 
@@ -123,7 +123,7 @@ def input_names(self):
         # Can use itertools.combinations(self._param_names, 2) with added
         # diagonal elements, or do double for loops if we switch to upper triangular
         input_names_list = list(itertools.product(self._param_names, self._param_names))
-        input_names_list = list(itertools.combinations_with_replacement(self._param_names, 2))
+        # input_names_list = list(itertools.combinations_with_replacement(self._param_names, 2))
         return input_names_list
 
     def equality_constraint_names(self):
@@ -157,7 +157,8 @@ def evaluate_equality_constraints(self):
     def evaluate_outputs(self):
         # Evaluates the objective value for the specified
         # ObjectiveLib type.
-        current_FIM = self._get_FIM()
+        # current_FIM = self._get_FIM()
+        current_FIM = self._input_values
 
         M = np.asarray(current_FIM, dtype=np.float64).reshape(
             self._n_params, self._n_params
@@ -212,11 +213,14 @@ def evaluate_jacobian_outputs(self):
         #
         # ToDo: there will be significant bookkeeping for more
         # complicated objective functions and the Hessian
-        current_FIM = self._get_FIM()
+        # current_FIM = self._get_FIM()
+        current_FIM = self._input_values
         M = np.asarray(current_FIM, dtype=np.float64).reshape(
             self._n_params, self._n_params
         )
 
+        # print(current_FIM)
+
         # May remove this warning. If so, we
         # should put the eigenvalue computation
         # within the eigenvalue-dependent
@@ -287,11 +291,12 @@ def evaluate_jacobian_outputs(self):
                 * (max_eig_term - safe_cond_number * min_eig_term)
             )
 
+        # print(jac_M)
         # Filter jac_M using the
         # masking matrix
-        jac_M = jac_M[self._masking_matrix > 0]
-        M_rows = np.zeros_like(jac_M)
-        M_cols = np.arange(len(jac_M))
+        # jac_M = jac_M[self._masking_matrix > 0]
+        # M_rows = np.zeros_like(jac_M)
+        # M_cols = np.arange(len(jac_M))
 
         # # Rows are the integer division by number of columns
         # M_rows = np.arange(len(jac_M.flatten())) // jac_M.shape[1]
@@ -299,14 +304,16 @@ def evaluate_jacobian_outputs(self):
         # # Columns are the remaindar (mod) by number of rows
         # M_cols = np.arange(len(jac_M.flatten())) % jac_M.shape[0]
 
-        # # Need to be flat?
-        # M_rows = np.zeros((len(jac_M.flatten()), 1)).flatten()
+        # Need to be flat?
+        M_rows = np.zeros((len(jac_M.flatten()), 1)).flatten()
 
-        # # Need to be flat?
-        # M_cols = np.arange(len(jac_M.flatten()))
+        # Need to be flat?
+        M_cols = np.arange(len(jac_M.flatten()))
 
         # Returns coo_matrix of the correct shape
         # print(coo_matrix((jac_M.flatten(), (M_rows, M_cols)), shape=(1, len(jac_M.flatten()))))
+        # print(jac_M)
+        # print(self.input_names())
         return coo_matrix(
             (jac_M.flatten(), (M_rows, M_cols)), shape=(1, len(jac_M.flatten()))
         )
@@ -326,66 +333,68 @@ def set_output_constraint_multipliers(self, output_con_multiplier_values):
             output_con_multiplier_values, dtype=np.float64
         )
 
-    def evaluate_hessian_equality_constraints(self):
-        #ToDo: Do any objectives require constraints?
-        #Returns coo_matrix of the correct shape
-        return None
-
-    def evaluate_hessian_outputs(self, FIM=None):
-        # ToDo: significant bookkeeping if the hessian's require vectorized
-        # operations. Just need mapping that works well and we are good.
-        if FIM is None:
-            current_FIM = self._get_FIM()
-        else:
-            current_FIM = FIM
-        M = np.asarray(current_FIM, dtype=np.float64).reshape(
-            self._n_params, self._n_params
-        )
-
-        # Hessian with correct size for using only the
-        # lower (upper) triangle of the FIM
-        hess = np.zeros((self._n_inputs, self._n_inputs))
-
-        from pyomo.contrib.doe import ObjectiveLib
-        if self.objective_option == ObjectiveLib.determinant:
-            # Grab inverse
-            Minv = np.linalg.pinv(M)
-
-            # Equation derived, shown in greybox
-            # pyomo.DoE 2.0 paper
-            # dMinv/dM(i,j,k,l) = -1/2(Minv[i, k]Minv[l, j] + 
-            #                          Minv[i, l]Minv[k, j])
-            lower_tri_inds_4D = itertools.combinations_with_replacement(range(self._n_params), 4)
-            for curr_location in lower_tri_inds_4D:
-                # For quadruples (i, j, k, l)...
-                # Row of hessian is sum from
-                # n - i + 1 to n minus i plus j
-                #
-                # Column of hessian is sum from
-                # n - k + 1 to n minus k plus l
-                i, j, k, l = curr_location
-                print(i, j, k, l)
-                row = sum(range(self._n_params - i + 1, self._n_params + 1)) - i + j
-                col = sum(range(self._n_params - k + 1, self._n_params + 1)) - k + l
-                hess[row, col] = -(1/2) * (Minv[i, k] * Minv[l, j] + Minv[i, l] * Minv[j, k])
+    # def evaluate_hessian_equality_constraints(self):
+    #     #ToDo: Do any objectives require constraints?
+    #     #Returns coo_matrix of the correct shape
+    #     return None
+
+    # def evaluate_hessian_outputs(self, FIM=None):
+    #     # ToDo: significant bookkeeping if the hessian's require vectorized
+    #     # operations. Just need mapping that works well and we are good.
+    #     if FIM is None:
+    #         current_FIM = self._get_FIM()
+    #     else:
+    #         current_FIM = FIM
+    #     M = np.asarray(current_FIM, dtype=np.float64).reshape(
+    #         self._n_params, self._n_params
+    #     )
+
+    #     # Hessian with correct size for using only the
+    #     # lower (upper) triangle of the FIM
+    #     hess = np.zeros((self._n_inputs, self._n_inputs))
+
+    #     from pyomo.contrib.doe import ObjectiveLib
+    #     if self.objective_option == ObjectiveLib.determinant:
+    #         # Grab inverse
+    #         Minv = np.linalg.pinv(M)
+
+    #         # Equation derived, shown in greybox
+    #         # pyomo.DoE 2.0 paper
+    #         # dMinv/dM(i,j,k,l) = -1/2(Minv[i, k]Minv[l, j] + 
+    #         #                          Minv[i, l]Minv[k, j])
+    #         lower_tri_inds_4D = itertools.combinations_with_replacement(range(self._n_params), 4)
+    #         for curr_location in lower_tri_inds_4D:
+    #             # For quadruples (i, j, k, l)...
+    #             # Row of hessian is sum from
+    #             # n - i + 1 to n minus i plus j
+    #             #
+    #             # Column of hessian is sum from
+    #             # n - k + 1 to n minus k plus l
+    #             i, j, k, l = curr_location
+    #             print(i, j, k, l)
+    #             row = sum(range(self._n_params - i + 1, self._n_params + 1)) - i + j
+    #             col = sum(range(self._n_params - k + 1, self._n_params + 1)) - k + l
+    #             #hess[row, col] = -(1/2) * (Minv[i, k] * Minv[l, j] + Minv[i, l] * Minv[j, k])
+    #             # New Formula (tested with finite differencing)
+    #             hess[row, col] = -(Minv[i, l] * Minv[k, j])
             
-            print(hess)
-            # Complete the full matrix
-            hess = hess.transpose()
-        elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
-            pass
-        elif self.objective_option == ObjectiveLib.condition_number:
-            pass
+    #         print(hess)
+    #         # Complete the full matrix
+    #         hess = hess.transpose()
+    #     elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
+    #         pass
+    #     elif self.objective_option == ObjectiveLib.condition_number:
+    #         pass
         
-        # Select only lower triangular values as a flat array
-        hess_masking_matrix = np.tril(np.ones_like(hess))
-        hess_data = hess[hess_masking_matrix > 0]
-        hess_rows, hess_cols  = np.tril_indices_from(hess)
-
-        print(hess_rows)
-        print(hess_cols)
-
-        # Returns coo_matrix of the correct shape
-        return coo_matrix(
-            (hess_data, (hess_rows, hess_cols)), shape=hess.shape
-        )
+    #     # Select only lower triangular values as a flat array
+    #     hess_masking_matrix = np.tril(np.ones_like(hess))
+    #     hess_data = hess[hess_masking_matrix > 0]
+    #     hess_rows, hess_cols  = np.tril_indices_from(hess)
+
+    #     print(hess_rows)
+    #     print(hess_cols)
+
+    #     # Returns coo_matrix of the correct shape
+    #     return coo_matrix(
+    #         (hess_data, (hess_rows, hess_cols)), shape=hess.shape
+    #     )

From afb2a41d576b0a0cf2369f275f566bf2c41ce52b Mon Sep 17 00:00:00 2001
From: Daniel Laky <dlaky@crcfe01.crc.nd.edu>
Date: Thu, 3 Apr 2025 14:02:16 -0400
Subject: [PATCH 021/143] changed solvers options for CRC solving

---
 pyomo/contrib/doe/doe.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index b4bcc7e49db..561cd602d68 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -209,10 +209,10 @@ def __init__(
             self.grey_box_solver = grey_box_solver
         else:
             grey_box_solver = pyo.SolverFactory("cyipopt")
-            # grey_box_solver.config.options['hessian_approximation'] = 'limited-memory'
-            # grey_box_solver.config.options["linear_solver"] = "ma57"
+            grey_box_solver.config.options['hessian_approximation'] = 'limited-memory'
+            grey_box_solver.config.options["linear_solver"] = "ma57"
             grey_box_solver.config.options['max_iter'] = 200
-            #grey_box_solver.config.options['tol'] = 1e-4
+            grey_box_solver.config.options['tol'] = 1e-4
             # grey_box_solver.config.options['mu_strategy'] = "monotone"
 
             self.grey_box_solver = grey_box_solver

From 01929f45d158bae4e6b0e29374ae92d636b3c18b Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 24 Apr 2025 14:34:56 -0400
Subject: [PATCH 022/143] Trying triangular FIM again, also add A-opt

---
 pyomo/contrib/doe/doe.py                |  4 +--
 pyomo/contrib/doe/grey_box_utilities.py | 38 ++++++++++++++++---------
 2 files changed, 26 insertions(+), 16 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index 65d924c5f81..54cd2e563b3 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -325,8 +325,8 @@ def FIM_egb_cons(m, p1, p2):
                 ).index(p2):
                     return model.fim[(p1, p2)] == m.egb_fim_block.inputs[(p2, p1)]
                 else:
-                    # return pyo.Constraint.Skip
-                    return model.fim[(p2, p1)] == m.egb_fim_block.inputs[(p2, p1)]
+                    return pyo.Constraint.Skip
+                    # return model.fim[(p2, p1)] == m.egb_fim_block.inputs[(p2, p1)]
 
             model.obj_cons.FIM_equalities = pyo.Constraint(
                 model.parameter_names, model.parameter_names, rule=FIM_egb_cons
diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index 7f789684601..d3db34f6c7a 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -93,10 +93,10 @@ def __init__(self, doe_object, objective_option="determinant", logger_level=None
         # Set initial values for inputs
         # Need a mask structure
         self._masking_matrix = np.triu(np.ones_like(self.doe_object.fim_initial))
-        self._input_values = np.asarray(self.doe_object.fim_initial.flatten(), dtype=np.float64)
-        # self._input_values = np.asarray(
-        #     self.doe_object.fim_initial[self._masking_matrix > 0], dtype=np.float64
-        # )
+        # self._input_values = np.asarray(self.doe_object.fim_initial.flatten(), dtype=np.float64)
+        self._input_values = np.asarray(
+            self.doe_object.fim_initial[self._masking_matrix > 0], dtype=np.float64
+        )
         self._n_inputs = len(self._input_values)
         # print(self._input_values)
 
@@ -122,8 +122,8 @@ def input_names(self):
         # Cartesian product gives us matrix indicies flattened in row-first format
         # Can use itertools.combinations(self._param_names, 2) with added
         # diagonal elements, or do double for loops if we switch to upper triangular
-        input_names_list = list(itertools.product(self._param_names, self._param_names))
-        # input_names_list = list(itertools.combinations_with_replacement(self._param_names, 2))
+        # input_names_list = list(itertools.product(self._param_names, self._param_names))
+        input_names_list = list(itertools.combinations_with_replacement(self._param_names, 2))
         return input_names_list
 
     def equality_constraint_names(self):
@@ -157,8 +157,8 @@ def evaluate_equality_constraints(self):
     def evaluate_outputs(self):
         # Evaluates the objective value for the specified
         # ObjectiveLib type.
-        # current_FIM = self._get_FIM()
-        current_FIM = self._input_values
+        current_FIM = self._get_FIM()
+        # current_FIM = self._input_values
 
         M = np.asarray(current_FIM, dtype=np.float64).reshape(
             self._n_params, self._n_params
@@ -167,7 +167,9 @@ def evaluate_outputs(self):
         # Change objective value based on ObjectiveLib type.
         from pyomo.contrib.doe import ObjectiveLib
 
-        if self.objective_option == ObjectiveLib.determinant:
+        if self.objective_option == ObjectiveLib.trace:
+            obj_value = np.trace(np.linalg.inv(M))
+        elif self.objective_option == ObjectiveLib.determinant:
             (sign, logdet) = np.linalg.slogdet(M)
             obj_value = logdet
         elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
@@ -193,7 +195,9 @@ def finalize_block_construction(self, pyomo_block):
         # Initialize log_determinant value
         from pyomo.contrib.doe import ObjectiveLib
 
-        if self.objective_option == ObjectiveLib.determinant:
+        if self.objective_option == ObjectiveLib.trace:
+            pyomo_block.outputs["A-opt"] = 0
+        elif self.objective_option == ObjectiveLib.determinant:
             pyomo_block.outputs["log10-D-opt"] = 0
         elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
             pyomo_block.outputs["E-opt"] = 0
@@ -213,8 +217,8 @@ def evaluate_jacobian_outputs(self):
         #
         # ToDo: there will be significant bookkeeping for more
         # complicated objective functions and the Hessian
-        # current_FIM = self._get_FIM()
-        current_FIM = self._input_values
+        current_FIM = self._get_FIM()
+        # current_FIM = self._input_values
         M = np.asarray(current_FIM, dtype=np.float64).reshape(
             self._n_params, self._n_params
         )
@@ -232,7 +236,13 @@ def evaluate_jacobian_outputs(self):
 
         from pyomo.contrib.doe import ObjectiveLib
 
-        if self.objective_option == ObjectiveLib.determinant:
+        if self.objective_option == ObjectiveLib.trace:
+            Minv = np.linalg.pinv(M)
+            # Derivative formula of A-optimality
+            # is -inv(FIM) @ inv(FIM). Add reference to 
+            # pyomo.DoE 2.0 manuscript S.I.
+            jac_M = -Minv @ Minv
+        elif self.objective_option == ObjectiveLib.determinant:
             Minv = np.linalg.pinv(M)
             # Derivative formula derived using tensor
             # calculus. Add reference to pyomo.DoE 2.0
@@ -294,7 +304,7 @@ def evaluate_jacobian_outputs(self):
         # print(jac_M)
         # Filter jac_M using the
         # masking matrix
-        # jac_M = jac_M[self._masking_matrix > 0]
+        jac_M = jac_M[self._masking_matrix > 0]
         # M_rows = np.zeros_like(jac_M)
         # M_cols = np.arange(len(jac_M))
 

From bb09c9c222db6ed2c2b6c3f5a2848fd61570c52c Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 24 Apr 2025 14:35:40 -0400
Subject: [PATCH 023/143] Starting to add testing

Adding functions for testing grey box derivative accuracy using numerical counterparts. Functions are working properly, just need to implement the derivatives/hessians in the grey box file.
---
 pyomo/contrib/doe/tests/test_greybox.py | 300 ++++++++++++++++++++++++
 1 file changed, 300 insertions(+)
 create mode 100644 pyomo/contrib/doe/tests/test_greybox.py

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
new file mode 100644
index 00000000000..0e598a97186
--- /dev/null
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -0,0 +1,300 @@
+#  ___________________________________________________________________________
+#
+#  Pyomo: Python Optimization Modeling Objects
+#  Copyright (c) 2008-2025
+#  National Technology and Engineering Solutions of Sandia, LLC
+#  Under the terms of Contract DE-NA0003525 with National Technology and
+#  Engineering Solutions of Sandia, LLC, the U.S. Government retains certain
+#  rights in this software.
+#  This software is distributed under the 3-clause BSD License.
+#  ___________________________________________________________________________
+import copy
+import json
+import os.path
+
+from pyomo.common.dependencies import (
+    numpy as np,
+    numpy_available,
+    pandas as pd,
+    pandas_available,
+)
+from pyomo.common.fileutils import this_file_dir
+import pyomo.common.unittest as unittest
+
+from pyomo.contrib.doe import DesignOfExperiments, FIMExternalGreyBox
+from pyomo.contrib.doe.examples.reactor_example import (
+    ReactorExperiment as FullReactorExperiment,
+)
+
+import pyomo.environ as pyo
+
+from pyomo.opt import SolverFactory
+
+ipopt_available = SolverFactory("ipopt").available()
+
+currdir = this_file_dir()
+file_path = os.path.join(currdir, "..", "examples", "result.json")
+
+with open(file_path) as f:
+    data_ex = json.load(f)
+
+data_ex["control_points"] = {float(k): v for k, v in data_ex["control_points"].items()}
+
+_FD_EPSILON = 1e-6  # Epsilon for numerical comparison of derivatives
+
+if numpy_available:
+    # Randomly generated P.S.D. matrix
+    # Matrix is 4x4 to match example 
+    # number of parameters.
+    testing_matrix = np.array([[5.13730123, 1.08084953, 1.6466824,  1.09943223],
+                               [1.08084953, 1.57183404, 1.50704403, 1.4969689],
+                               [1.6466824,  1.50704403, 2.54754738, 1.39902838],
+                               [1.09943223, 1.4969689,  1.39902838, 1.57406692]])
+    
+    masking_matrix = np.triu(np.ones_like(testing_matrix))
+
+
+def get_numerical_derivative(grey_box_object=None):
+    # Internal import to avoid circular imports
+    from pyomo.contrib.doe import ObjectiveLib
+
+    # Grab current FIM value
+    current_FIM = grey_box_object._get_FIM()
+    dim = current_FIM.shape[0]
+    unperturbed_value = 0
+
+    # Find the initial value of the function
+    if grey_box_object.objective_option == ObjectiveLib.trace:
+        unperturbed_value = np.trace(np.linalg.inv(current_FIM))
+    elif grey_box_object.objective_option == ObjectiveLib.determinant:
+        unperturbed_value = np.log(np.linalg.det(current_FIM))
+    elif grey_box_object.objective_option == ObjectiveLib.minimum_eigenvalue:
+        vals_init, vecs_init = np.linalg.eig(current_FIM)
+        unperturbed_value = np.min(vals_init)
+    elif grey_box_object.objective_option == ObjectiveLib.condition_number:
+        unperturbed_value = np.linalg.cond(current_FIM)
+
+    # Calculate the numerical derivative, using forward difference
+    numerical_derivative = np.zeros_like(current_FIM)
+
+    # perturb each direction
+    for i in range(dim):
+        for j in range(dim):
+            FIM_perturbed = copy.deepcopy(current_FIM)
+            FIM_perturbed[i, j] += _FD_EPSILON
+            
+            new_value_ij = 0
+            # Test which method is being used:
+            if grey_box_object.objective_option == ObjectiveLib.trace:
+                new_value_ij = np.trace(np.linalg.inv(FIM_perturbed))
+            elif grey_box_object.objective_option == ObjectiveLib.determinant:
+                new_value_ij = np.log(np.linalg.det(FIM_perturbed))
+            elif grey_box_object.objective_option == ObjectiveLib.minimum_eigenvalue:
+                vals, vecs = np.linalg.eig(FIM_perturbed)
+                new_value_ij = np.min(vals)
+            elif grey_box_object.objective_option == ObjectiveLib.condition_number:
+                new_value_ij = np.linalg.cond(FIM_perturbed)
+            
+            # Calculate the derivative value from forward difference
+            diff = (new_value_ij - unperturbed_value) / _FD_EPSILON
+
+            numerical_derivative[i, j] = diff
+    
+    return numerical_derivative
+
+
+def get_numerical_second_derivative(grey_box_object=None):
+    # Internal import to avoid circular imports
+    from pyomo.contrib.doe import ObjectiveLib
+
+    # Grab current FIM value
+    current_FIM = grey_box_object._get_FIM()
+    dim = current_FIM.shape[0]
+
+    # Calculate the numerical derivative, 
+    # using second order formula
+    numerical_derivative = np.zeros([dim, dim, dim, dim])
+
+    # perturb each direction
+    for i in range(dim):
+        for j in range(dim):
+            for k in range(dim):
+                for l in range(dim):
+                    FIM_perturbed_1 = copy.deepcopy(current_FIM)
+                    FIM_perturbed_2 = copy.deepcopy(current_FIM)
+                    FIM_perturbed_3 = copy.deepcopy(current_FIM)
+                    FIM_perturbed_4 = copy.deepcopy(current_FIM)
+
+                    # Need 4 perturbations to cover the
+                    # formula H[i, j] = [(FIM + eps (both))
+                    # + (FIM +/- eps one each)
+                    # + (FIM -/+ eps one each)
+                    # + (FIM - eps (both))] / (4*eps**2)
+                    FIM_perturbed_1[i, j] += _FD_EPSILON
+                    FIM_perturbed_1[k, l] += _FD_EPSILON
+
+                    FIM_perturbed_2[i, j] += _FD_EPSILON
+                    FIM_perturbed_2[k, l] += -_FD_EPSILON
+
+                    FIM_perturbed_3[i, j] += -_FD_EPSILON
+                    FIM_perturbed_3[k, l] += _FD_EPSILON
+
+                    FIM_perturbed_4[i, j] += -_FD_EPSILON
+                    FIM_perturbed_4[k, l] += -_FD_EPSILON
+                    
+                    new_values = np.array([0., 0., 0., 0.])
+                    # Test which method is being used:
+                    if grey_box_object.objective_option == ObjectiveLib.trace:
+                        new_values[0] = np.trace(np.linalg.inv(FIM_perturbed_1))
+                        new_values[1] = np.trace(np.linalg.inv(FIM_perturbed_2))
+                        new_values[2] = np.trace(np.linalg.inv(FIM_perturbed_3))
+                        new_values[3] = np.trace(np.linalg.inv(FIM_perturbed_4))
+                    elif grey_box_object.objective_option == ObjectiveLib.determinant:
+                        new_values[0] = np.log(np.linalg.det(FIM_perturbed_1))
+                        new_values[1] = np.log(np.linalg.det(FIM_perturbed_2))
+                        new_values[2] = np.log(np.linalg.det(FIM_perturbed_3))
+                        new_values[3] = np.log(np.linalg.det(FIM_perturbed_4))
+                    elif grey_box_object.objective_option == ObjectiveLib.minimum_eigenvalue:
+                        vals, vecs = np.linalg.eig(FIM_perturbed_1)
+                        new_values[0] = np.min(vals)
+                        vals, vecs = np.linalg.eig(FIM_perturbed_2)
+                        new_values[1] = np.min(vals)
+                        vals, vecs = np.linalg.eig(FIM_perturbed_3)
+                        new_values[2] = np.min(vals)
+                        vals, vecs = np.linalg.eig(FIM_perturbed_4)
+                        new_values[3] = np.min(vals)
+                    elif grey_box_object.objective_option == ObjectiveLib.condition_number:
+                        new_values[0] = np.linalg.cond(FIM_perturbed_1)
+                        new_values[1] = np.linalg.cond(FIM_perturbed_2)
+                        new_values[2] = np.linalg.cond(FIM_perturbed_3)
+                        new_values[3] = np.linalg.cond(FIM_perturbed_4)
+                    
+                    # Calculate the derivative value from second order difference formula
+                    diff = (new_values[0] - new_values[1] - new_values[2] + new_values[3]) / (4 * _FD_EPSILON**2)
+
+                    numerical_derivative[i, j, k, l] = diff
+    
+    return numerical_derivative
+
+
+def get_FIM_FIMPrior_Q_L(doe_obj=None):
+    """
+    Helper function to retrieve results to compare.
+
+    """
+    model = doe_obj.model
+
+    n_param = doe_obj.n_parameters
+    n_y = doe_obj.n_experiment_outputs
+
+    FIM_vals = [
+        pyo.value(model.fim[i, j])
+        for i in model.parameter_names
+        for j in model.parameter_names
+    ]
+    FIM_prior_vals = [
+        pyo.value(model.prior_FIM[i, j])
+        for i in model.parameter_names
+        for j in model.parameter_names
+    ]
+    if hasattr(model, "L"):
+        L_vals = [
+            pyo.value(model.L[i, j])
+            for i in model.parameter_names
+            for j in model.parameter_names
+        ]
+    else:
+        L_vals = [[0] * n_param] * n_param
+    Q_vals = [
+        pyo.value(model.sensitivity_jacobian[i, j])
+        for i in model.output_names
+        for j in model.parameter_names
+    ]
+    sigma_inv = [1 / v for k, v in model.scenario_blocks[0].measurement_error.items()]
+    param_vals = np.array(
+        [[v for k, v in model.scenario_blocks[0].unknown_parameters.items()]]
+    )
+
+    FIM_vals_np = np.array(FIM_vals).reshape((n_param, n_param))
+    FIM_prior_vals_np = np.array(FIM_prior_vals).reshape((n_param, n_param))
+
+    for i in range(n_param):
+        for j in range(n_param):
+            if j < i:
+                FIM_vals_np[j, i] = FIM_vals_np[i, j]
+
+    L_vals_np = np.array(L_vals).reshape((n_param, n_param))
+    Q_vals_np = np.array(Q_vals).reshape((n_y, n_param))
+
+    sigma_inv_np = np.zeros((n_y, n_y))
+
+    for ind, v in enumerate(sigma_inv):
+        sigma_inv_np[ind, ind] = v
+
+    return FIM_vals_np, FIM_prior_vals_np, Q_vals_np, L_vals_np, sigma_inv_np
+
+
+def get_standard_args(experiment, fd_method, obj_used):
+    args = {}
+    args['experiment'] = experiment
+    args['fd_formula'] = fd_method
+    args['step'] = 1e-3
+    args['objective_option'] = obj_used
+    args['scale_constant_value'] = 1
+    args['scale_nominal_param_value'] = True
+    args['prior_FIM'] = None
+    args['jac_initial'] = None
+    args['fim_initial'] = None
+    args['L_diagonal_lower_bound'] = 1e-7
+    args['solver'] = None
+    args['tee'] = False
+    args['get_labeled_model_args'] = None
+    args['_Cholesky_option'] = True
+    args['_only_compute_fim_lower'] = True
+    return args
+
+
+# Understanding how to build an object to test the derivative values
+fd_method = "central"
+obj_used = "trace"
+
+experiment = FullReactorExperiment(data_ex, 10, 3)
+
+DoE_args = get_standard_args(experiment, fd_method, obj_used)
+DoE_args["use_grey_box_objective"] = True
+
+doe_obj = DesignOfExperiments(**DoE_args)
+
+doe_obj.create_doe_model()
+
+grey_box_object = FIMExternalGreyBox(doe_object=doe_obj, objective_option=doe_obj.objective_option)
+
+print(grey_box_object.input_names())
+print(grey_box_object._input_values)
+print(testing_matrix)
+print(testing_matrix[masking_matrix > 0])
+# Set the input values
+grey_box_object.set_input_values(testing_matrix[masking_matrix > 0])
+print(grey_box_object._get_FIM())
+print(grey_box_object.evaluate_outputs())
+print(np.log(np.linalg.det(grey_box_object._get_FIM())))
+utri_vals_jac = grey_box_object.evaluate_jacobian_outputs().toarray()
+jac = np.zeros_like(grey_box_object._get_FIM())
+jac[np.triu_indices_from(jac)] = utri_vals_jac
+jac += jac.transpose() - np.diag(np.diag(jac))
+print(jac)
+print(get_numerical_derivative(grey_box_object))
+print((jac - get_numerical_derivative(grey_box_object)) / jac)
+print(get_numerical_second_derivative(grey_box_object))
+
+@unittest.skipIf(not ipopt_available, "The 'ipopt' command is not available")
+@unittest.skipIf(not numpy_available, "Numpy is not available")
+class TestReactorExampleBuild(unittest.TestCase):
+    def dummy_test(self):
+        self.assertTrue(1)
+    # Tests:
+    # See google doc for complete list of tests
+
+
+if __name__ == "__main__":
+    unittest.main()

From 73e10b49153ddd9abb10b5bbe17649dd3e25b79f Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Mon, 28 Apr 2025 14:15:51 -0400
Subject: [PATCH 024/143] Began adding tests. Ran Black

---
 pyomo/contrib/doe/doe.py                      |  6 +-
 .../doe/examples/grey_box_D_opt_comparison.py |  4 +-
 .../doe/examples/grey_box_test_hessian.py     |  6 +-
 pyomo/contrib/doe/grey_box_utilities.py       | 17 ++--
 pyomo/contrib/doe/tests/test_greybox.py       | 82 ++++++++++++++-----
 5 files changed, 79 insertions(+), 36 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index 54cd2e563b3..d0d01148fa8 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -211,7 +211,7 @@ def __init__(
             # solver.options["linear_solver"] = "MUMPS"
             solver.options["halt_on_ampl_error"] = "yes"
             solver.options["max_iter"] = 3000
-            #solver.options["tol"] = 1e-4
+            # solver.options["tol"] = 1e-4
             self.solver = solver
 
         self.tee = tee
@@ -419,7 +419,9 @@ def FIM_egb_cons(m, p1, p2):
             # Set objective value
             if self.objective_option == ObjectiveLib.determinant:
                 det_val = np.linalg.det(np.array(self.get_FIM()))
-                model.obj_cons.egb_fim_block.outputs["log10-D-opt"].set_value(np.log(det_val))
+                model.obj_cons.egb_fim_block.outputs["log10-D-opt"].set_value(
+                    np.log(det_val)
+                )
             elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
                 eig, _ = np.linalg.eig(np.array(self.get_FIM()))
                 model.obj_cons.egb_fim_block.outputs["E-opt"].set_value(np.min(eig))
diff --git a/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py b/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
index a95313007e4..f4b53a6ed80 100644
--- a/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
+++ b/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
@@ -136,7 +136,7 @@ def compare_reactor_doe():
     #     )
     # )
     print(
-        ("\tTemperature values: [""{:.2f}]").format(
+        ("\tTemperature values: [" "{:.2f}]").format(
             doe_obj_grey_box.results["Experiment Design"][1]
         )
     )
@@ -173,7 +173,7 @@ def compare_reactor_doe():
     #     )
     # )
     print(
-        ("\tTemperature values: [""{:.2f}]").format(
+        ("\tTemperature values: [" "{:.2f}]").format(
             doe_obj.results["Experiment Design"][1]
         )
     )
diff --git a/pyomo/contrib/doe/examples/grey_box_test_hessian.py b/pyomo/contrib/doe/examples/grey_box_test_hessian.py
index 5f3ff81b4a6..ff1f5d5f2ee 100644
--- a/pyomo/contrib/doe/examples/grey_box_test_hessian.py
+++ b/pyomo/contrib/doe/examples/grey_box_test_hessian.py
@@ -49,8 +49,8 @@ def compare_reactor_doe():
     objective_option = "determinant"
     scale_nominal_param_value = True
 
-    #solver = pyo.SolverFactory("ipopt")
-    #solver.options["linear_solver"] = "mumps"
+    # solver = pyo.SolverFactory("ipopt")
+    # solver.options["linear_solver"] = "mumps"
 
     # DoE object to compute FIM prior
     # doe_obj = DesignOfExperiments(
@@ -98,7 +98,7 @@ def compare_reactor_doe():
 
     doe_obj.run_doe()
 
-    grey_box_check = FIMExternalGreyBox(doe_object=doe_obj, )
+    grey_box_check = FIMExternalGreyBox(doe_object=doe_obj)
     return grey_box_check, doe_obj
 
 
diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index d3db34f6c7a..40487eb9877 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -75,6 +75,7 @@ def __init__(self, doe_object, objective_option="determinant", logger_level=None
         #       have been satisfied before the FIM is created. Can add check for unknown_parameters...
         if objective_option == "determinant":
             from pyomo.contrib.doe import ObjectiveLib
+
             objective_option = ObjectiveLib(objective_option)
         self.objective_option = (
             objective_option  # Add failsafe to make sure this is ObjectiveLib object?
@@ -123,7 +124,9 @@ def input_names(self):
         # Can use itertools.combinations(self._param_names, 2) with added
         # diagonal elements, or do double for loops if we switch to upper triangular
         # input_names_list = list(itertools.product(self._param_names, self._param_names))
-        input_names_list = list(itertools.combinations_with_replacement(self._param_names, 2))
+        input_names_list = list(
+            itertools.combinations_with_replacement(self._param_names, 2)
+        )
         return input_names_list
 
     def equality_constraint_names(self):
@@ -178,7 +181,7 @@ def evaluate_outputs(self):
         elif self.objective_option == ObjectiveLib.condition_number:
             eig, _ = np.linalg.eig(M)
             obj_value = np.max(eig) / np.min(eig)
-        
+
         # print(obj_value)
 
         return np.asarray([obj_value], dtype=np.float64)
@@ -232,14 +235,14 @@ def evaluate_jacobian_outputs(self):
         eig_vals, eig_vecs = np.linalg.eig(M)
         if min(eig_vals) <= 1:
             pass
-            #print("Warning: {:0.6f}".format(min(eig_vals)))
+            # print("Warning: {:0.6f}".format(min(eig_vals)))
 
         from pyomo.contrib.doe import ObjectiveLib
 
         if self.objective_option == ObjectiveLib.trace:
             Minv = np.linalg.pinv(M)
             # Derivative formula of A-optimality
-            # is -inv(FIM) @ inv(FIM). Add reference to 
+            # is -inv(FIM) @ inv(FIM). Add reference to
             # pyomo.DoE 2.0 manuscript S.I.
             jac_M = -Minv @ Minv
         elif self.objective_option == ObjectiveLib.determinant:
@@ -370,7 +373,7 @@ def set_output_constraint_multipliers(self, output_con_multiplier_values):
 
     #         # Equation derived, shown in greybox
     #         # pyomo.DoE 2.0 paper
-    #         # dMinv/dM(i,j,k,l) = -1/2(Minv[i, k]Minv[l, j] + 
+    #         # dMinv/dM(i,j,k,l) = -1/2(Minv[i, k]Minv[l, j] +
     #         #                          Minv[i, l]Minv[k, j])
     #         lower_tri_inds_4D = itertools.combinations_with_replacement(range(self._n_params), 4)
     #         for curr_location in lower_tri_inds_4D:
@@ -387,7 +390,7 @@ def set_output_constraint_multipliers(self, output_con_multiplier_values):
     #             #hess[row, col] = -(1/2) * (Minv[i, k] * Minv[l, j] + Minv[i, l] * Minv[j, k])
     #             # New Formula (tested with finite differencing)
     #             hess[row, col] = -(Minv[i, l] * Minv[k, j])
-            
+
     #         print(hess)
     #         # Complete the full matrix
     #         hess = hess.transpose()
@@ -395,7 +398,7 @@ def set_output_constraint_multipliers(self, output_con_multiplier_values):
     #         pass
     #     elif self.objective_option == ObjectiveLib.condition_number:
     #         pass
-        
+
     #     # Select only lower triangular values as a flat array
     #     hess_masking_matrix = np.tril(np.ones_like(hess))
     #     hess_data = hess[hess_masking_matrix > 0]
diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 0e598a97186..28316bcf7a3 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -44,13 +44,17 @@
 
 if numpy_available:
     # Randomly generated P.S.D. matrix
-    # Matrix is 4x4 to match example 
+    # Matrix is 4x4 to match example
     # number of parameters.
-    testing_matrix = np.array([[5.13730123, 1.08084953, 1.6466824,  1.09943223],
-                               [1.08084953, 1.57183404, 1.50704403, 1.4969689],
-                               [1.6466824,  1.50704403, 2.54754738, 1.39902838],
-                               [1.09943223, 1.4969689,  1.39902838, 1.57406692]])
-    
+    testing_matrix = np.array(
+        [
+            [5.13730123, 1.08084953, 1.6466824, 1.09943223],
+            [1.08084953, 1.57183404, 1.50704403, 1.4969689],
+            [1.6466824, 1.50704403, 2.54754738, 1.39902838],
+            [1.09943223, 1.4969689, 1.39902838, 1.57406692],
+        ]
+    )
+
     masking_matrix = np.triu(np.ones_like(testing_matrix))
 
 
@@ -82,7 +86,7 @@ def get_numerical_derivative(grey_box_object=None):
         for j in range(dim):
             FIM_perturbed = copy.deepcopy(current_FIM)
             FIM_perturbed[i, j] += _FD_EPSILON
-            
+
             new_value_ij = 0
             # Test which method is being used:
             if grey_box_object.objective_option == ObjectiveLib.trace:
@@ -94,12 +98,12 @@ def get_numerical_derivative(grey_box_object=None):
                 new_value_ij = np.min(vals)
             elif grey_box_object.objective_option == ObjectiveLib.condition_number:
                 new_value_ij = np.linalg.cond(FIM_perturbed)
-            
+
             # Calculate the derivative value from forward difference
             diff = (new_value_ij - unperturbed_value) / _FD_EPSILON
 
             numerical_derivative[i, j] = diff
-    
+
     return numerical_derivative
 
 
@@ -111,7 +115,7 @@ def get_numerical_second_derivative(grey_box_object=None):
     current_FIM = grey_box_object._get_FIM()
     dim = current_FIM.shape[0]
 
-    # Calculate the numerical derivative, 
+    # Calculate the numerical derivative,
     # using second order formula
     numerical_derivative = np.zeros([dim, dim, dim, dim])
 
@@ -141,8 +145,8 @@ def get_numerical_second_derivative(grey_box_object=None):
 
                     FIM_perturbed_4[i, j] += -_FD_EPSILON
                     FIM_perturbed_4[k, l] += -_FD_EPSILON
-                    
-                    new_values = np.array([0., 0., 0., 0.])
+
+                    new_values = np.array([0.0, 0.0, 0.0, 0.0])
                     # Test which method is being used:
                     if grey_box_object.objective_option == ObjectiveLib.trace:
                         new_values[0] = np.trace(np.linalg.inv(FIM_perturbed_1))
@@ -154,7 +158,10 @@ def get_numerical_second_derivative(grey_box_object=None):
                         new_values[1] = np.log(np.linalg.det(FIM_perturbed_2))
                         new_values[2] = np.log(np.linalg.det(FIM_perturbed_3))
                         new_values[3] = np.log(np.linalg.det(FIM_perturbed_4))
-                    elif grey_box_object.objective_option == ObjectiveLib.minimum_eigenvalue:
+                    elif (
+                        grey_box_object.objective_option
+                        == ObjectiveLib.minimum_eigenvalue
+                    ):
                         vals, vecs = np.linalg.eig(FIM_perturbed_1)
                         new_values[0] = np.min(vals)
                         vals, vecs = np.linalg.eig(FIM_perturbed_2)
@@ -163,17 +170,22 @@ def get_numerical_second_derivative(grey_box_object=None):
                         new_values[2] = np.min(vals)
                         vals, vecs = np.linalg.eig(FIM_perturbed_4)
                         new_values[3] = np.min(vals)
-                    elif grey_box_object.objective_option == ObjectiveLib.condition_number:
+                    elif (
+                        grey_box_object.objective_option
+                        == ObjectiveLib.condition_number
+                    ):
                         new_values[0] = np.linalg.cond(FIM_perturbed_1)
                         new_values[1] = np.linalg.cond(FIM_perturbed_2)
                         new_values[2] = np.linalg.cond(FIM_perturbed_3)
                         new_values[3] = np.linalg.cond(FIM_perturbed_4)
-                    
+
                     # Calculate the derivative value from second order difference formula
-                    diff = (new_values[0] - new_values[1] - new_values[2] + new_values[3]) / (4 * _FD_EPSILON**2)
+                    diff = (
+                        new_values[0] - new_values[1] - new_values[2] + new_values[3]
+                    ) / (4 * _FD_EPSILON**2)
 
                     numerical_derivative[i, j, k, l] = diff
-    
+
     return numerical_derivative
 
 
@@ -246,7 +258,10 @@ def get_standard_args(experiment, fd_method, obj_used):
     args['jac_initial'] = None
     args['fim_initial'] = None
     args['L_diagonal_lower_bound'] = 1e-7
-    args['solver'] = None
+    # Change when we can access other solvers
+    solver = SolverFactory("ipopt")
+    solver.options["linear_solver"] = "MUMPS"
+    args['solver'] = solver
     args['tee'] = False
     args['get_labeled_model_args'] = None
     args['_Cholesky_option'] = True
@@ -267,7 +282,9 @@ def get_standard_args(experiment, fd_method, obj_used):
 
 doe_obj.create_doe_model()
 
-grey_box_object = FIMExternalGreyBox(doe_object=doe_obj, objective_option=doe_obj.objective_option)
+grey_box_object = FIMExternalGreyBox(
+    doe_object=doe_obj, objective_option=doe_obj.objective_option
+)
 
 print(grey_box_object.input_names())
 print(grey_box_object._input_values)
@@ -287,11 +304,32 @@ def get_standard_args(experiment, fd_method, obj_used):
 print((jac - get_numerical_derivative(grey_box_object)) / jac)
 print(get_numerical_second_derivative(grey_box_object))
 
-@unittest.skipIf(not ipopt_available, "The 'ipopt' command is not available")
+
+# @unittest.skipIf(not ipopt_available, "The 'ipopt' command is not available")
 @unittest.skipIf(not numpy_available, "Numpy is not available")
-class TestReactorExampleBuild(unittest.TestCase):
-    def dummy_test(self):
+class TestFIMExternalGreyBox(unittest.TestCase):
+    # Begin with tests on calculating
+    # derivatives.
+    def jacobian_test_A_opt(self):
+        # Make the object
+        fd_method = "central"
+        obj_used = "trace"
+
+        experiment = FullReactorExperiment(data_ex, 10, 3)
+
+        DoE_args = get_standard_args(experiment, fd_method, obj_used)
+        DoE_args["use_grey_box_objective"] = True
+
+        doe_obj = DesignOfExperiments(**DoE_args)
+        doe_obj.create_doe_model()
+
+        grey_box_object = FIMExternalGreyBox(
+            doe_object=doe_obj, objective_option=doe_obj.objective_option
+        )
+
+        # Compute the derivative given
         self.assertTrue(1)
+
     # Tests:
     # See google doc for complete list of tests
 

From b093c48ae3d54902789e00baaf291161e06bc4e8 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Mon, 28 Apr 2025 14:43:51 -0400
Subject: [PATCH 025/143] Add first test.

---
 pyomo/contrib/doe/tests/test_greybox.py | 61 +++++++------------------
 1 file changed, 17 insertions(+), 44 deletions(-)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 28316bcf7a3..6c336ac84e4 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -269,48 +269,10 @@ def get_standard_args(experiment, fd_method, obj_used):
     return args
 
 
-# Understanding how to build an object to test the derivative values
-fd_method = "central"
-obj_used = "trace"
-
-experiment = FullReactorExperiment(data_ex, 10, 3)
-
-DoE_args = get_standard_args(experiment, fd_method, obj_used)
-DoE_args["use_grey_box_objective"] = True
-
-doe_obj = DesignOfExperiments(**DoE_args)
-
-doe_obj.create_doe_model()
-
-grey_box_object = FIMExternalGreyBox(
-    doe_object=doe_obj, objective_option=doe_obj.objective_option
-)
-
-print(grey_box_object.input_names())
-print(grey_box_object._input_values)
-print(testing_matrix)
-print(testing_matrix[masking_matrix > 0])
-# Set the input values
-grey_box_object.set_input_values(testing_matrix[masking_matrix > 0])
-print(grey_box_object._get_FIM())
-print(grey_box_object.evaluate_outputs())
-print(np.log(np.linalg.det(grey_box_object._get_FIM())))
-utri_vals_jac = grey_box_object.evaluate_jacobian_outputs().toarray()
-jac = np.zeros_like(grey_box_object._get_FIM())
-jac[np.triu_indices_from(jac)] = utri_vals_jac
-jac += jac.transpose() - np.diag(np.diag(jac))
-print(jac)
-print(get_numerical_derivative(grey_box_object))
-print((jac - get_numerical_derivative(grey_box_object)) / jac)
-print(get_numerical_second_derivative(grey_box_object))
-
-
-# @unittest.skipIf(not ipopt_available, "The 'ipopt' command is not available")
+@unittest.skipIf(not ipopt_available, "The 'ipopt' command is not available")
 @unittest.skipIf(not numpy_available, "Numpy is not available")
 class TestFIMExternalGreyBox(unittest.TestCase):
-    # Begin with tests on calculating
-    # derivatives.
-    def jacobian_test_A_opt(self):
+    def test_jacobian_A_opt(self):
         # Make the object
         fd_method = "central"
         obj_used = "trace"
@@ -327,11 +289,22 @@ def jacobian_test_A_opt(self):
             doe_object=doe_obj, objective_option=doe_obj.objective_option
         )
 
-        # Compute the derivative given
-        self.assertTrue(1)
+        # Set input values to the random testing matrix
+        grey_box_object.set_input_values(testing_matrix[masking_matrix > 0])
+
+        # Grab the Jacobian values
+        utri_vals_jac = grey_box_object.evaluate_jacobian_outputs().toarray()
+
+        # Recover the Jacobian in Matrix Form
+        jac = np.zeros_like(grey_box_object._get_FIM())
+        jac[np.triu_indices_from(jac)] = utri_vals_jac
+        jac += jac.transpose() - np.diag(np.diag(jac))
+
+        # Get numerical derivative matrix
+        jac_FD = get_numerical_derivative(grey_box_object)
 
-    # Tests:
-    # See google doc for complete list of tests
+        # assert that each component is close
+        self.assertTrue(np.all(np.isclose(jac, jac_FD)))
 
 
 if __name__ == "__main__":

From d764cc0fb51a4c21054d60e04d38165af3d47478 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Mon, 28 Apr 2025 14:46:05 -0400
Subject: [PATCH 026/143] Finishing Jacobian Tests

---
 pyomo/contrib/doe/tests/test_greybox.py | 102 ++++++++++++++++++++++++
 1 file changed, 102 insertions(+)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 6c336ac84e4..516ce1a9be4 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -305,6 +305,108 @@ def test_jacobian_A_opt(self):
 
         # assert that each component is close
         self.assertTrue(np.all(np.isclose(jac, jac_FD)))
+    
+    def test_jacobian_A_opt(self):
+        # Make the object
+        fd_method = "central"
+        obj_used = "determinant"
+
+        experiment = FullReactorExperiment(data_ex, 10, 3)
+
+        DoE_args = get_standard_args(experiment, fd_method, obj_used)
+        DoE_args["use_grey_box_objective"] = True
+
+        doe_obj = DesignOfExperiments(**DoE_args)
+        doe_obj.create_doe_model()
+
+        grey_box_object = FIMExternalGreyBox(
+            doe_object=doe_obj, objective_option=doe_obj.objective_option
+        )
+
+        # Set input values to the random testing matrix
+        grey_box_object.set_input_values(testing_matrix[masking_matrix > 0])
+
+        # Grab the Jacobian values
+        utri_vals_jac = grey_box_object.evaluate_jacobian_outputs().toarray()
+
+        # Recover the Jacobian in Matrix Form
+        jac = np.zeros_like(grey_box_object._get_FIM())
+        jac[np.triu_indices_from(jac)] = utri_vals_jac
+        jac += jac.transpose() - np.diag(np.diag(jac))
+
+        # Get numerical derivative matrix
+        jac_FD = get_numerical_derivative(grey_box_object)
+
+        # assert that each component is close
+        self.assertTrue(np.all(np.isclose(jac, jac_FD)))
+    
+    def test_jacobian_A_opt(self):
+        # Make the object
+        fd_method = "central"
+        obj_used = "minimum_eigenvalue"
+
+        experiment = FullReactorExperiment(data_ex, 10, 3)
+
+        DoE_args = get_standard_args(experiment, fd_method, obj_used)
+        DoE_args["use_grey_box_objective"] = True
+
+        doe_obj = DesignOfExperiments(**DoE_args)
+        doe_obj.create_doe_model()
+
+        grey_box_object = FIMExternalGreyBox(
+            doe_object=doe_obj, objective_option=doe_obj.objective_option
+        )
+
+        # Set input values to the random testing matrix
+        grey_box_object.set_input_values(testing_matrix[masking_matrix > 0])
+
+        # Grab the Jacobian values
+        utri_vals_jac = grey_box_object.evaluate_jacobian_outputs().toarray()
+
+        # Recover the Jacobian in Matrix Form
+        jac = np.zeros_like(grey_box_object._get_FIM())
+        jac[np.triu_indices_from(jac)] = utri_vals_jac
+        jac += jac.transpose() - np.diag(np.diag(jac))
+
+        # Get numerical derivative matrix
+        jac_FD = get_numerical_derivative(grey_box_object)
+
+        # assert that each component is close
+        self.assertTrue(np.all(np.isclose(jac, jac_FD)))
+    
+    def test_jacobian_A_opt(self):
+        # Make the object
+        fd_method = "central"
+        obj_used = "condition_number"
+
+        experiment = FullReactorExperiment(data_ex, 10, 3)
+
+        DoE_args = get_standard_args(experiment, fd_method, obj_used)
+        DoE_args["use_grey_box_objective"] = True
+
+        doe_obj = DesignOfExperiments(**DoE_args)
+        doe_obj.create_doe_model()
+
+        grey_box_object = FIMExternalGreyBox(
+            doe_object=doe_obj, objective_option=doe_obj.objective_option
+        )
+
+        # Set input values to the random testing matrix
+        grey_box_object.set_input_values(testing_matrix[masking_matrix > 0])
+
+        # Grab the Jacobian values
+        utri_vals_jac = grey_box_object.evaluate_jacobian_outputs().toarray()
+
+        # Recover the Jacobian in Matrix Form
+        jac = np.zeros_like(grey_box_object._get_FIM())
+        jac[np.triu_indices_from(jac)] = utri_vals_jac
+        jac += jac.transpose() - np.diag(np.diag(jac))
+
+        # Get numerical derivative matrix
+        jac_FD = get_numerical_derivative(grey_box_object)
+
+        # assert that each component is close
+        self.assertTrue(np.all(np.isclose(jac, jac_FD)))
 
 
 if __name__ == "__main__":

From 3899d864fab24bc95b5acd2d7afea4b329d52781 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Mon, 28 Apr 2025 14:47:56 -0400
Subject: [PATCH 027/143] Corrected test names.

---
 pyomo/contrib/doe/tests/test_greybox.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 516ce1a9be4..4ca524898b2 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -305,8 +305,8 @@ def test_jacobian_A_opt(self):
 
         # assert that each component is close
         self.assertTrue(np.all(np.isclose(jac, jac_FD)))
-    
-    def test_jacobian_A_opt(self):
+
+    def test_jacobian_D_opt(self):
         # Make the object
         fd_method = "central"
         obj_used = "determinant"
@@ -339,8 +339,8 @@ def test_jacobian_A_opt(self):
 
         # assert that each component is close
         self.assertTrue(np.all(np.isclose(jac, jac_FD)))
-    
-    def test_jacobian_A_opt(self):
+
+    def test_jacobian_E_opt(self):
         # Make the object
         fd_method = "central"
         obj_used = "minimum_eigenvalue"
@@ -373,8 +373,8 @@ def test_jacobian_A_opt(self):
 
         # assert that each component is close
         self.assertTrue(np.all(np.isclose(jac, jac_FD)))
-    
-    def test_jacobian_A_opt(self):
+
+    def test_jacobian_ME_opt(self):
         # Make the object
         fd_method = "central"
         obj_used = "condition_number"

From 0bb706bfec16a4a579699d5fadf6f50811b3209c Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Mon, 28 Apr 2025 15:24:19 -0400
Subject: [PATCH 028/143] Adding input and output value tests.

---
 pyomo/contrib/doe/tests/test_greybox.py | 158 +++++++++++++++---------
 1 file changed, 98 insertions(+), 60 deletions(-)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 4ca524898b2..8b893cffe95 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -269,25 +269,102 @@ def get_standard_args(experiment, fd_method, obj_used):
     return args
 
 
-@unittest.skipIf(not ipopt_available, "The 'ipopt' command is not available")
-@unittest.skipIf(not numpy_available, "Numpy is not available")
-class TestFIMExternalGreyBox(unittest.TestCase):
-    def test_jacobian_A_opt(self):
-        # Make the object
-        fd_method = "central"
-        obj_used = "trace"
+def make_greybox_and_doe_objects(objective_option):
+    fd_method = "central"
+    obj_used = objective_option
 
-        experiment = FullReactorExperiment(data_ex, 10, 3)
+    experiment = FullReactorExperiment(data_ex, 10, 3)
 
-        DoE_args = get_standard_args(experiment, fd_method, obj_used)
-        DoE_args["use_grey_box_objective"] = True
+    DoE_args = get_standard_args(experiment, fd_method, obj_used)
+    DoE_args["use_grey_box_objective"] = True
 
-        doe_obj = DesignOfExperiments(**DoE_args)
-        doe_obj.create_doe_model()
+    doe_obj = DesignOfExperiments(**DoE_args)
+    doe_obj.create_doe_model()
 
-        grey_box_object = FIMExternalGreyBox(
-            doe_object=doe_obj, objective_option=doe_obj.objective_option
-        )
+    grey_box_object = FIMExternalGreyBox(
+        doe_object=doe_obj, objective_option=doe_obj.objective_option
+    )
+    
+    return doe_obj, grey_box_object
+
+
+@unittest.skipIf(not ipopt_available, "The 'ipopt' command is not available")
+@unittest.skipIf(not numpy_available, "Numpy is not available")
+class TestFIMExternalGreyBox(unittest.TestCase):
+    # Test that we can properly
+    # set the inputs for the
+    # Grey Box object
+    def test_set_inputs(self):
+        objective_option = "trace"
+        doe_obj, grey_box_object = make_greybox_and_doe_objects(objective_option=objective_option)
+        
+        # Set input values to the random testing matrix
+        grey_box_object.set_input_values(testing_matrix[masking_matrix > 0])
+        
+        # Grab the values from get_FIM
+        grey_box_FIM = grey_box_object._get_FIM()
+        
+        self.assertTrue(np.all(np.isclose(grey_box_FIM, testing_matrix)))
+        
+    
+    # Testing output computation
+    def test_outputs_A_opt(self):
+        objective_option = "trace"
+        doe_obj, grey_box_object = make_greybox_and_doe_objects(objective_option=objective_option)
+        
+        # Set input values to the random testing matrix
+        grey_box_object.set_input_values(testing_matrix[masking_matrix > 0])
+        
+        grey_box_A_opt = grey_box_object.evaluate_outputs()
+        
+        A_opt = np.trace(np.linalg.inv(testing_matrix))
+        
+        self.assertTrue(np.isclose(grey_box_A_opt, A_opt))
+    
+    def test_outputs_D_opt(self):
+        objective_option = "determinant"
+        doe_obj, grey_box_object = make_greybox_and_doe_objects(objective_option=objective_option)
+        
+        # Set input values to the random testing matrix
+        grey_box_object.set_input_values(testing_matrix[masking_matrix > 0])
+        
+        grey_box_D_opt = grey_box_object.evaluate_outputs()
+        
+        D_opt = np.log(np.linalg.det(testing_matrix))
+        
+        self.assertTrue(np.isclose(grey_box_D_opt, D_opt))
+    
+    def test_outputs_E_opt(self):
+        objective_option = "minimum_eigenvalue"
+        doe_obj, grey_box_object = make_greybox_and_doe_objects(objective_option=objective_option)
+        
+        # Set input values to the random testing matrix
+        grey_box_object.set_input_values(testing_matrix[masking_matrix > 0])
+        
+        grey_box_E_opt = grey_box_object.evaluate_outputs()
+        
+        vals, vecs = np.linalg.eig(testing_matrix)
+        E_opt = np.min(vals)
+        
+        self.assertTrue(np.isclose(grey_box_E_opt, E_opt))
+    
+    def test_outputs_ME_opt(self):
+        objective_option = "condition_number"
+        doe_obj, grey_box_object = make_greybox_and_doe_objects(objective_option=objective_option)
+        
+        # Set input values to the random testing matrix
+        grey_box_object.set_input_values(testing_matrix[masking_matrix > 0])
+        
+        grey_box_ME_opt = grey_box_object.evaluate_outputs()
+        
+        ME_opt = np.linalg.cond(testing_matrix)
+        
+        self.assertTrue(np.isclose(grey_box_ME_opt, ME_opt))
+    
+    # Testing Jacobian computation
+    def test_jacobian_A_opt(self):
+        objective_option = "trace"
+        doe_obj, grey_box_object = make_greybox_and_doe_objects(objective_option=objective_option)
 
         # Set input values to the random testing matrix
         grey_box_object.set_input_values(testing_matrix[masking_matrix > 0])
@@ -307,21 +384,8 @@ def test_jacobian_A_opt(self):
         self.assertTrue(np.all(np.isclose(jac, jac_FD)))
 
     def test_jacobian_D_opt(self):
-        # Make the object
-        fd_method = "central"
-        obj_used = "determinant"
-
-        experiment = FullReactorExperiment(data_ex, 10, 3)
-
-        DoE_args = get_standard_args(experiment, fd_method, obj_used)
-        DoE_args["use_grey_box_objective"] = True
-
-        doe_obj = DesignOfExperiments(**DoE_args)
-        doe_obj.create_doe_model()
-
-        grey_box_object = FIMExternalGreyBox(
-            doe_object=doe_obj, objective_option=doe_obj.objective_option
-        )
+        objective_option = "determinant"
+        doe_obj, grey_box_object = make_greybox_and_doe_objects(objective_option=objective_option)
 
         # Set input values to the random testing matrix
         grey_box_object.set_input_values(testing_matrix[masking_matrix > 0])
@@ -341,21 +405,8 @@ def test_jacobian_D_opt(self):
         self.assertTrue(np.all(np.isclose(jac, jac_FD)))
 
     def test_jacobian_E_opt(self):
-        # Make the object
-        fd_method = "central"
-        obj_used = "minimum_eigenvalue"
-
-        experiment = FullReactorExperiment(data_ex, 10, 3)
-
-        DoE_args = get_standard_args(experiment, fd_method, obj_used)
-        DoE_args["use_grey_box_objective"] = True
-
-        doe_obj = DesignOfExperiments(**DoE_args)
-        doe_obj.create_doe_model()
-
-        grey_box_object = FIMExternalGreyBox(
-            doe_object=doe_obj, objective_option=doe_obj.objective_option
-        )
+        objective_option = "minimum_eigenvalue"
+        doe_obj, grey_box_object = make_greybox_and_doe_objects(objective_option=objective_option)
 
         # Set input values to the random testing matrix
         grey_box_object.set_input_values(testing_matrix[masking_matrix > 0])
@@ -375,21 +426,8 @@ def test_jacobian_E_opt(self):
         self.assertTrue(np.all(np.isclose(jac, jac_FD)))
 
     def test_jacobian_ME_opt(self):
-        # Make the object
-        fd_method = "central"
-        obj_used = "condition_number"
-
-        experiment = FullReactorExperiment(data_ex, 10, 3)
-
-        DoE_args = get_standard_args(experiment, fd_method, obj_used)
-        DoE_args["use_grey_box_objective"] = True
-
-        doe_obj = DesignOfExperiments(**DoE_args)
-        doe_obj.create_doe_model()
-
-        grey_box_object = FIMExternalGreyBox(
-            doe_object=doe_obj, objective_option=doe_obj.objective_option
-        )
+        objective_option = "condition_number"
+        doe_obj, grey_box_object = make_greybox_and_doe_objects(objective_option=objective_option)
 
         # Set input values to the random testing matrix
         grey_box_object.set_input_values(testing_matrix[masking_matrix > 0])

From 0670562ca1ff060961dea496cc03f533a4fdacd5 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Mon, 28 Apr 2025 15:25:26 -0400
Subject: [PATCH 029/143] Ran black.

---
 pyomo/contrib/doe/tests/test_greybox.py | 87 +++++++++++++++----------
 1 file changed, 52 insertions(+), 35 deletions(-)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 8b893cffe95..bf5eb3f29da 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -284,7 +284,7 @@ def make_greybox_and_doe_objects(objective_option):
     grey_box_object = FIMExternalGreyBox(
         doe_object=doe_obj, objective_option=doe_obj.objective_option
     )
-    
+
     return doe_obj, grey_box_object
 
 
@@ -296,75 +296,86 @@ class TestFIMExternalGreyBox(unittest.TestCase):
     # Grey Box object
     def test_set_inputs(self):
         objective_option = "trace"
-        doe_obj, grey_box_object = make_greybox_and_doe_objects(objective_option=objective_option)
-        
+        doe_obj, grey_box_object = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
+
         # Set input values to the random testing matrix
         grey_box_object.set_input_values(testing_matrix[masking_matrix > 0])
-        
+
         # Grab the values from get_FIM
         grey_box_FIM = grey_box_object._get_FIM()
-        
+
         self.assertTrue(np.all(np.isclose(grey_box_FIM, testing_matrix)))
-        
-    
+
     # Testing output computation
     def test_outputs_A_opt(self):
         objective_option = "trace"
-        doe_obj, grey_box_object = make_greybox_and_doe_objects(objective_option=objective_option)
-        
+        doe_obj, grey_box_object = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
+
         # Set input values to the random testing matrix
         grey_box_object.set_input_values(testing_matrix[masking_matrix > 0])
-        
+
         grey_box_A_opt = grey_box_object.evaluate_outputs()
-        
+
         A_opt = np.trace(np.linalg.inv(testing_matrix))
-        
+
         self.assertTrue(np.isclose(grey_box_A_opt, A_opt))
-    
+
     def test_outputs_D_opt(self):
         objective_option = "determinant"
-        doe_obj, grey_box_object = make_greybox_and_doe_objects(objective_option=objective_option)
-        
+        doe_obj, grey_box_object = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
+
         # Set input values to the random testing matrix
         grey_box_object.set_input_values(testing_matrix[masking_matrix > 0])
-        
+
         grey_box_D_opt = grey_box_object.evaluate_outputs()
-        
+
         D_opt = np.log(np.linalg.det(testing_matrix))
-        
+
         self.assertTrue(np.isclose(grey_box_D_opt, D_opt))
-    
+
     def test_outputs_E_opt(self):
         objective_option = "minimum_eigenvalue"
-        doe_obj, grey_box_object = make_greybox_and_doe_objects(objective_option=objective_option)
-        
+        doe_obj, grey_box_object = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
+
         # Set input values to the random testing matrix
         grey_box_object.set_input_values(testing_matrix[masking_matrix > 0])
-        
+
         grey_box_E_opt = grey_box_object.evaluate_outputs()
-        
+
         vals, vecs = np.linalg.eig(testing_matrix)
         E_opt = np.min(vals)
-        
+
         self.assertTrue(np.isclose(grey_box_E_opt, E_opt))
-    
+
     def test_outputs_ME_opt(self):
         objective_option = "condition_number"
-        doe_obj, grey_box_object = make_greybox_and_doe_objects(objective_option=objective_option)
-        
+        doe_obj, grey_box_object = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
+
         # Set input values to the random testing matrix
         grey_box_object.set_input_values(testing_matrix[masking_matrix > 0])
-        
+
         grey_box_ME_opt = grey_box_object.evaluate_outputs()
-        
+
         ME_opt = np.linalg.cond(testing_matrix)
-        
+
         self.assertTrue(np.isclose(grey_box_ME_opt, ME_opt))
-    
+
     # Testing Jacobian computation
     def test_jacobian_A_opt(self):
         objective_option = "trace"
-        doe_obj, grey_box_object = make_greybox_and_doe_objects(objective_option=objective_option)
+        doe_obj, grey_box_object = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
 
         # Set input values to the random testing matrix
         grey_box_object.set_input_values(testing_matrix[masking_matrix > 0])
@@ -385,7 +396,9 @@ def test_jacobian_A_opt(self):
 
     def test_jacobian_D_opt(self):
         objective_option = "determinant"
-        doe_obj, grey_box_object = make_greybox_and_doe_objects(objective_option=objective_option)
+        doe_obj, grey_box_object = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
 
         # Set input values to the random testing matrix
         grey_box_object.set_input_values(testing_matrix[masking_matrix > 0])
@@ -406,7 +419,9 @@ def test_jacobian_D_opt(self):
 
     def test_jacobian_E_opt(self):
         objective_option = "minimum_eigenvalue"
-        doe_obj, grey_box_object = make_greybox_and_doe_objects(objective_option=objective_option)
+        doe_obj, grey_box_object = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
 
         # Set input values to the random testing matrix
         grey_box_object.set_input_values(testing_matrix[masking_matrix > 0])
@@ -427,7 +442,9 @@ def test_jacobian_E_opt(self):
 
     def test_jacobian_ME_opt(self):
         objective_option = "condition_number"
-        doe_obj, grey_box_object = make_greybox_and_doe_objects(objective_option=objective_option)
+        doe_obj, grey_box_object = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
 
         # Set input values to the random testing matrix
         grey_box_object.set_input_values(testing_matrix[masking_matrix > 0])

From 15b0ecc97e2955045e05cd19a6070305399477cd Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Mon, 28 Apr 2025 15:54:00 -0400
Subject: [PATCH 030/143] Fixed typos

---
 pyomo/contrib/doe/doe.py                    | 4 ++--
 pyomo/contrib/doe/examples/grey_box_test.py | 6 +++---
 pyomo/contrib/doe/grey_box_utilities.py     | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index d0d01148fa8..090c72ce15b 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -296,7 +296,7 @@ def run_doe(self, model=None, results_file=None):
         # Add the objective function to the model
         if self.use_grey_box:
             # Add external grey box block to a block named ``obj_cons`` to
-            # resuse material for initializing the objective-free square model
+            # reuse material for initializing the objective-free square model
             # ToDo: Make this naming convention robust
             model.obj_cons = pyo.Block()
             # ToDo: Add functionality for grey box objectives
@@ -336,7 +336,7 @@ def FIM_egb_cons(m, p1, p2):
             model.fim_constraint.pprint()
 
             # ToDo: Add naming convention to adjust name of objective output
-            # to conincide with the ObjectiveLib type
+            # to coincide with the ObjectiveLib type
             # ToDo: Write test for each option successfully building
             if self.objective_option == ObjectiveLib.determinant:
                 model.objective = pyo.Objective(
diff --git a/pyomo/contrib/doe/examples/grey_box_test.py b/pyomo/contrib/doe/examples/grey_box_test.py
index 2bac1ef3451..c2dbee9ba70 100644
--- a/pyomo/contrib/doe/examples/grey_box_test.py
+++ b/pyomo/contrib/doe/examples/grey_box_test.py
@@ -26,7 +26,7 @@ def __init__(
         print_level=0,
     ):
         """
-        Greybox model to compute the log determinant of a sqaure symmetric matrix.
+        Greybox model to compute the log determinant of a square symmetric matrix.
 
         Arguments
         ---------
@@ -42,7 +42,7 @@ def __init__(
             0 (default): no extra output
             1: minimal info to indicate if initialized well
                 print the following:
-                - initial FIM received by the grey-box moduel
+                - initial FIM received by the grey-box module
             2: intermediate info for debugging
                 print all the level 1 print statements, plus:
                 - the FIM output of the current iteration, both the output as the FIM matrix, and the flattened vector
@@ -129,7 +129,7 @@ def finalize_block_construction(self, pyomo_block):
         ---------
         pyomo_block: pass the created pyomo block here
         """
-        # ele_to_order map the input position in FIM, like (a,b), to its flattend index
+        # ele_to_order map the input position in FIM, like (a,b), to its flattened index
         # for e.g., ele_to_order[(0,0)] = 0
         # trash = input(str(inspect.stack()[0][3]))
 
diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index 40487eb9877..f41e515712d 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -120,7 +120,7 @@ def _get_FIM(self):
         return current_FIM
 
     def input_names(self):
-        # Cartesian product gives us matrix indicies flattened in row-first format
+        # Cartesian product gives us matrix indices flattened in row-first format
         # Can use itertools.combinations(self._param_names, 2) with added
         # diagonal elements, or do double for loops if we switch to upper triangular
         # input_names_list = list(itertools.product(self._param_names, self._param_names))

From 364c15b448b50810c79315169c2d93cb6a709f6d Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Mon, 28 Apr 2025 16:17:16 -0400
Subject: [PATCH 031/143] Remove grey_box_test file

---
 pyomo/contrib/doe/examples/grey_box_test.py | 337 --------------------
 1 file changed, 337 deletions(-)
 delete mode 100644 pyomo/contrib/doe/examples/grey_box_test.py

diff --git a/pyomo/contrib/doe/examples/grey_box_test.py b/pyomo/contrib/doe/examples/grey_box_test.py
deleted file mode 100644
index c2dbee9ba70..00000000000
--- a/pyomo/contrib/doe/examples/grey_box_test.py
+++ /dev/null
@@ -1,337 +0,0 @@
-import numpy as np
-import pyomo.environ as pyo
-from scipy.sparse import coo_matrix
-from pyomo.contrib.pynumero.interfaces.external_grey_box import (
-    ExternalGreyBoxModel,
-    ExternalGreyBoxBlock,
-)
-
-import inspect
-from pathlib import Path
-
-
-try:
-    inspect.stack()[1]
-    print(Path(inspect.stack()[1].filename).absolute)
-except:
-    print("No stack()[1]...")
-
-
-class LogDetModel(ExternalGreyBoxModel):
-    def __init__(
-        self,
-        n_parameters=2,
-        initial_fim=None,
-        use_exact_derivatives=True,
-        print_level=0,
-    ):
-        """
-        Greybox model to compute the log determinant of a square symmetric matrix.
-
-        Arguments
-        ---------
-        n_parameters: int
-            Number of parameters in the model. The square symmetric matrix is of shape n_parameters*n_parameters
-        initial_fim: dict
-            key: tuple (i,j) where i, j are the row, column number of FIM. value: FIM[i,j]
-            Initial value of the matrix. If None, the identity matrix is used.
-        use_exact_derivatives: bool
-            If True, the exact derivatives are used.
-            If False, the finite difference approximation can be used, but not recommended/tested.
-        print_level: integer
-            0 (default): no extra output
-            1: minimal info to indicate if initialized well
-                print the following:
-                - initial FIM received by the grey-box module
-            2: intermediate info for debugging
-                print all the level 1 print statements, plus:
-                - the FIM output of the current iteration, both the output as the FIM matrix, and the flattened vector
-            3: all details for debugging
-                print all the level 2 print statements, plus:
-                - the log determinant of the FIM output of the current iteration
-                - the eigen values of the FIM output of the current iteration
-
-        Return
-        ------
-        None
-        """
-        trash = input(str(inspect.stack()[0][3]))
-
-        self._use_exact_derivatives = use_exact_derivatives
-        self.print_level = print_level
-        self.n_parameters = n_parameters
-        # make sure it's integer since this is a number of inputs that shouldn't be fractional
-        self.num_input = int(
-            n_parameters + (n_parameters * n_parameters - n_parameters) / 2
-        )
-        self.initial_fim = initial_fim
-
-        # variable to store the output value
-        # Output constraint multiplier values. This is a 1-element vector because there is one output
-        self._output_con_mult_values = np.zeros(1)
-
-        if not use_exact_derivatives:
-            raise NotImplementedError("use_exact_derivatives == False not supported")
-
-    def input_names(self):
-        """Return the names of the inputs.
-        Define only the upper triangle of FIM because FIM is symmetric
-
-        Return
-        ------
-        input_name_list: a list of the names of inputs
-        """
-        # trash = input(str(inspect.stack()[0][3]))
-
-        # store the input names as a tuple
-        input_name_list = []
-        # loop over parameters
-        for i in range(self.n_parameters):
-            # loop over upper triangle
-            for j in range(i, self.n_parameters):
-                input_name_list.append((i, j))
-
-        return input_name_list
-
-    def equality_constraint_names(self):
-        """Return the names of the equality constraints."""
-        # no equality constraints
-        # trash = input(str(inspect.stack()[0][3]))
-        return []
-
-    def output_names(self):
-        """Return the names of the outputs."""
-        # trash = input(str(inspect.stack()[0][3]))
-        return ["log_det"]
-
-    def set_output_constraint_multipliers(self, output_con_multiplier_values):
-        """
-        Set the values of the output constraint multipliers.
-
-        Arguments
-        ---------
-        output_con_multiplier_values: a scalar number for the output constraint multipliers
-        """
-        # trash = input(str(inspect.stack()[0][3]))
-
-        # because we only have one output constraint, the length is 1
-        if len(output_con_multiplier_values) != 1:
-            raise ValueError("Output should be a scalar value. ")
-
-        np.copyto(self._output_con_mult_values, output_con_multiplier_values)
-
-    def finalize_block_construction(self, pyomo_block):
-        """
-        Finalize the construction of the ExternalGreyBoxBlock.
-        This function initializes the inputs with an initial value
-
-        Arguments
-        ---------
-        pyomo_block: pass the created pyomo block here
-        """
-        # ele_to_order map the input position in FIM, like (a,b), to its flattened index
-        # for e.g., ele_to_order[(0,0)] = 0
-        # trash = input(str(inspect.stack()[0][3]))
-
-        ele_to_order = {}
-        count = 0
-
-        if self.print_level >= 1:
-            if self.initial_fim is not None:
-                print("Grey-box initialize inputs with: ", self.initial_fim)
-            else:
-                print("Grey-box initialize inputs with an identity matrix.")
-
-        # only generating upper triangular part
-        # loop over parameters
-        for i in range(self.n_parameters):
-            # loop over parameters from current parameter to end
-            for j in range(i, self.n_parameters):
-                # flatten (i,j)
-                ele_to_order[(i, j)] = count
-                # this tuple is the position of this input in the FIM
-                tuple_name = (i, j)
-
-                # if an initial FIM is given, we can initialize with these values
-                if self.initial_fim is not None:
-                    pyomo_block.inputs[tuple_name].value = self.initial_fim[tuple_name]
-
-                # if not given initial FIM, we initialize with an identity matrix
-                else:
-                    # identity matrix
-                    if i == j:
-                        pyomo_block.inputs[tuple_name].value = 1
-                    else:
-                        pyomo_block.inputs[tuple_name].value = 0
-
-                count += 1
-
-        self.ele_to_order = ele_to_order
-
-    def set_input_values(self, input_values):
-        """
-        Set the values of the inputs.
-        This function refers to the notebook:
-        https://colab.research.google.com/drive/1VplaeOTes87oSznboZXoz-q5W6gKJ9zZ?usp=sharing
-
-        Arguments
-        ---------
-        input_values: input initial values
-        """
-        # see the colab link in the doc string for why this should be a list
-        self._input_values = list(input_values)
-
-        # trash = input(str(inspect.stack()[0][3]))
-
-    def evaluate_equality_constraints(self):
-        """Evaluate the equality constraints.
-        Return None because there are no equality constraints.
-        """
-        trash = input(str(inspect.stack()[0][3]))
-
-        return None
-
-    def evaluate_outputs(self):
-        """
-        Evaluate the output of the model.
-        We call numpy here to compute the logdet of FIM. slogdet is used to avoid ill-conditioning issue
-        This function refers to the notebook:
-        https://colab.research.google.com/drive/1VplaeOTes87oSznboZXoz-q5W6gKJ9zZ?usp=sharing
-
-        Return
-        ------
-        logdet: a one-element numpy array, containing the log det value as float
-        """
-        # trash = input(str(inspect.stack()[0][3]))
-
-        # form matrix as a list of lists
-        M = self._extract_and_assemble_fim()
-
-        # compute log determinant
-        (sign, logdet) = np.linalg.slogdet(M)
-
-        if self.print_level >= 2:
-            print("iteration")
-            print("\n Consider M =\n", M)
-            print("Solution: ", self._input_values)
-            if self.print_level == 3:
-                print("   logdet = ", logdet, "\n")
-                print("Eigvals:", np.linalg.eigvals(M))
-
-        # see the colab link in the doc string for why this should be a array with dtype as float64
-        return np.asarray([logdet], dtype=np.float64)
-
-    def evaluate_jacobian_equality_constraints(self):
-        """Evaluate the Jacobian of the equality constraints."""
-        # trash = input(str(inspect.stack()[0][3]))
-        return None
-
-    def _extract_and_assemble_fim(self):
-        """
-        This function make the flattened inputs back into the shape of an FIM
-
-        Return
-        ------
-        M: a numpy array containing FIM.
-        """
-        # trash = input(str(inspect.stack()[0][3]))
-
-        # FIM shape Np*Np
-        M = np.zeros((self.n_parameters, self.n_parameters))
-        # loop over parameters.
-        # Expand here to be the full matrix.
-        for i in range(self.n_parameters):
-            for k in range(self.n_parameters):
-                #  get symmetry part.
-                # only have upper triangle, so the smaller index is the row number
-                row_number, col_number = min(i, k), max(i, k)
-                M[i, k] = self._input_values[
-                    self.ele_to_order[(row_number, col_number)]
-                ]
-
-        return M
-
-    def evaluate_jacobian_outputs(self):
-        """
-        Evaluate the Jacobian of the outputs.
-
-        Return
-        ------
-        A sparse matrix, containing the first order gradient of the OBJ, in the shape [1,N_input]
-        where N_input is the No. of off-diagonal elements//2 + Np
-        """
-        # trash = input(str(inspect.stack()[0][3]))
-
-        if self._use_exact_derivatives:
-            M = self._extract_and_assemble_fim()
-
-            # compute pseudo inverse to be more numerically stable
-            Minv = np.linalg.pinv(M)
-
-            # compute gradient of log determinant
-            row = np.zeros(self.num_input)  # to store row index
-            col = np.zeros(self.num_input)  # to store column index
-            data = np.zeros(self.num_input)  # to store data
-
-            # construct gradients as a sparse matrix
-            # loop over the upper triangular
-            # loop over parameters
-            for i in range(self.n_parameters):
-                # loop over parameters from current parameter to end
-                for j in range(i, self.n_parameters):
-                    order = self.ele_to_order[(i, j)]
-                    # diagonal elements. See Eq. 16 in paper for explanation
-                    if i == j:
-                        row[order], col[order], data[order] = (0, order, Minv[i, j])
-                    # off-diagonal elements
-                    else:  # factor = 2 since it is a symmetric matrix. See Eq. 16 in paper for explanation
-                        row[order], col[order], data[order] = (0, order, 2 * Minv[i, j])
-            # sparse matrix
-            return coo_matrix((data, (row, col)), shape=(1, self.num_input))
-
-
-# import idaes
-
-m = pyo.ConcreteModel()
-m.params = pyo.Set(initialize=[0, 1])
-m.params_mat = m.params * m.params
-m.M = pyo.Var(m.params_mat, bounds=(0, 50), initialize=1)
-
-print('Made base model.')
-
-ex_model = LogDetModel(
-    n_parameters=2,
-    initial_fim=None,
-    # initial_fim=np.ones((2, 2)),
-    print_level=1,
-)
-
-print('Added logdet model')
-m.egb = ExternalGreyBoxBlock(external_model=ex_model)
-
-print('Added as external grey box.')
-
-# constraining outputs
-m.M_con1 = pyo.Constraint(expr=(m.M[(0, 0)] == m.egb.inputs[(0, 0)]))
-m.M_con2 = pyo.Constraint(expr=(m.M[(0, 1)] == m.egb.inputs[(0, 1)]))
-m.M_con3 = pyo.Constraint(expr=(m.M[(1, 1)] == m.egb.inputs[(1, 1)]))
-m.M_con4 = pyo.Constraint(expr=(m.M[(1, 0)] == m.M[(0, 1)]))
-
-print('Added constraints on symmetry for FIM.')
-
-m.logdet = pyo.Expression(rule=m.egb.outputs["log_det"])
-
-m.obj = pyo.Objective(expr=m.logdet, sense=pyo.maximize)
-
-print('Added objective function. Solve is next action.')
-
-solver = pyo.SolverFactory("cyipopt")
-solver.config.options['hessian_approximation'] = 'limited-memory'
-# solver.config.options['mu_strategy'] = 'monotone'
-# solver.config.options['linear_solver'] = 'ma27'
-
-solver.solve(m, tee=True)
-
-m.M.pprint()
-
-# m.pprint()

From 2e5ba6834517305a9b1dd75197526fdb0b27f118 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Tue, 29 Apr 2025 12:38:19 -0400
Subject: [PATCH 032/143] Move grey box objective to its own function

Moved the creation of the objective if grey box is active to its own function (so we can build the model without solving).
---
 pyomo/contrib/doe/doe.py | 137 +++++++++++++++++++++------------------
 1 file changed, 75 insertions(+), 62 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index 090c72ce15b..4c3ec237054 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -295,68 +295,7 @@ def run_doe(self, model=None, results_file=None):
 
         # Add the objective function to the model
         if self.use_grey_box:
-            # Add external grey box block to a block named ``obj_cons`` to
-            # reuse material for initializing the objective-free square model
-            # ToDo: Make this naming convention robust
-            model.obj_cons = pyo.Block()
-            # ToDo: Add functionality for grey box objectives
-            grey_box_FIM = FIMExternalGreyBox(
-                doe_object=self,
-                objective_option=self.objective_option,
-                logger_level=self.logger.getEffectiveLevel(),
-            )
-            model.obj_cons.egb_fim_block = ExternalGreyBoxBlock(
-                external_model=grey_box_FIM
-            )
-
-            # Adding constraints to for all grey box input values to equate to fim values
-            def FIM_egb_cons(m, p1, p2):
-                """
-
-                m: Pyomo model
-                p1: parameter 1
-                p2: parameter 2
-
-                """
-                # Using upper triangular egb to
-                # use easier naming conventions.
-                if list(model.parameter_names).index(p1) >= list(
-                    model.parameter_names
-                ).index(p2):
-                    return model.fim[(p1, p2)] == m.egb_fim_block.inputs[(p2, p1)]
-                else:
-                    return pyo.Constraint.Skip
-                    # return model.fim[(p2, p1)] == m.egb_fim_block.inputs[(p2, p1)]
-
-            model.obj_cons.FIM_equalities = pyo.Constraint(
-                model.parameter_names, model.parameter_names, rule=FIM_egb_cons
-            )
-
-            model.obj_cons.pprint()
-            model.fim_constraint.pprint()
-
-            # ToDo: Add naming convention to adjust name of objective output
-            # to coincide with the ObjectiveLib type
-            # ToDo: Write test for each option successfully building
-            if self.objective_option == ObjectiveLib.determinant:
-                model.objective = pyo.Objective(
-                    expr=model.obj_cons.egb_fim_block.outputs["log10-D-opt"],
-                    sense=pyo.maximize,
-                )
-            elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
-                model.objective = pyo.Objective(
-                    expr=model.obj_cons.egb_fim_block.outputs["E-opt"],
-                    sense=pyo.maximize,
-                )
-            elif self.objective_option == ObjectiveLib.condition_number:
-                model.objective = pyo.Objective(
-                    expr=model.obj_cons.egb_fim_block.outputs["ME-opt"],
-                    sense=pyo.minimize,
-                )
-            else:
-                raise AttributeError(
-                    "Objective option not recognized. Please contact the developers as you should not see this error."
-                )
+            self.create_grey_box_objective_function(model=model)
         else:
             self.create_objective_function(model=model)
 
@@ -1440,6 +1379,80 @@ def determinant_general(b):
             # add dummy objective function
             model.objective = pyo.Objective(expr=0)
 
+    def create_grey_box_objective_function(self, model=None):
+        # Add external grey box block to a block named ``obj_cons`` to
+        # reuse material for initializing the objective-free square model
+        if model is None:
+            model = model = self.model
+        
+        # ToDo: Make this naming convention robust
+        model.obj_cons = pyo.Block()
+        
+        # Create FIM External Grey Box object
+        grey_box_FIM = FIMExternalGreyBox(
+            doe_object=self,
+            objective_option=self.objective_option,
+            logger_level=self.logger.getEffectiveLevel(),
+        )
+        
+        # Attach External Grey Box Model
+        # to the model as an External 
+        # Grey Box Block
+        model.obj_cons.egb_fim_block = ExternalGreyBoxBlock(
+            external_model=grey_box_FIM
+        )
+
+        # Adding constraints to for all grey box input values to equate to fim values
+        def FIM_egb_cons(m, p1, p2):
+            """
+
+            m: Pyomo model
+            p1: parameter 1
+            p2: parameter 2
+
+            """
+            # Using upper triangular FIM to
+            # make numerics better.
+            if list(model.parameter_names).index(p1) >= list(
+                model.parameter_names
+            ).index(p2):
+                return model.fim[(p1, p2)] == m.egb_fim_block.inputs[(p2, p1)]
+            else:
+                return pyo.Constraint.Skip
+
+        # Add the FIM and External Grey 
+        # Box inputs constraints
+        model.obj_cons.FIM_equalities = pyo.Constraint(
+            model.parameter_names, model.parameter_names, rule=FIM_egb_cons
+        )
+
+        # Add objective based on user provided
+        # type within ObjectiveLib
+        if self.objective_option == ObjectiveLib.trace:
+            model.objective = pyo.Objective(
+                expr=model.obj_cons.egb_fim_block.outputs["A-opt"],
+                sense=pyo.minimize,
+            )
+        elif self.objective_option == ObjectiveLib.determinant:
+            model.objective = pyo.Objective(
+                expr=model.obj_cons.egb_fim_block.outputs["log10-D-opt"],
+                sense=pyo.maximize,
+            )
+        elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
+            model.objective = pyo.Objective(
+                expr=model.obj_cons.egb_fim_block.outputs["E-opt"],
+                sense=pyo.maximize,
+            )
+        elif self.objective_option == ObjectiveLib.condition_number:
+            model.objective = pyo.Objective(
+                expr=model.obj_cons.egb_fim_block.outputs["ME-opt"],
+                sense=pyo.minimize,
+            )
+        else:
+            raise AttributeError(
+                "Objective option not recognized. Please contact the developers as you should not see this error."
+            )
+
     # Check to see if the model has all the required suffixes
     def check_model_labels(self, model=None):
         """

From 94c23b037571fd42b0f0851a0f4f5b45380085a7 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Tue, 29 Apr 2025 12:40:29 -0400
Subject: [PATCH 033/143] Cleaned up some comments/documentation

---
 pyomo/contrib/doe/doe.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index 4c3ec237054..8151db9810b 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -305,9 +305,12 @@ def run_doe(self, model=None, results_file=None):
             "Successfully built the DoE model.\nBuild time: %0.1f seconds" % build_time
         )
 
-        # Solve the square problem first to initialize the fim and
-        # sensitivity constraints
-        # Deactivate objective expression and objective constraints (on a block), and fix design variables
+        # Solve the square problem first to 
+        # initialize the fim and
+        # sensitivity constraints. First, we
+        # Deactivate objective expression and 
+        # objective constraints (on a block), 
+        # and fix the design variables.
         model.objective.deactivate()
         model.obj_cons.deactivate()
         for comp in model.scenario_blocks[0].experiment_inputs:
@@ -322,9 +325,6 @@ def run_doe(self, model=None, results_file=None):
         #     # The solver was unsuccessful, might want to warn the user or terminate gracefully, etc.
         model.dummy_obj = pyo.Objective(expr=0, sense=pyo.minimize)
         self.solver.solve(model, tee=self.tee)
-        # from idaes.core.util import DiagnosticsToolbox
-        # dt = DiagnosticsToolbox(model)
-        # dt.display_extreme_jacobian_entries()
 
         # Track time to initialize the DoE model
         initialization_time = sp_timer.toc(msg=None)

From 3b583b4040f5937aef18aea88dfb274f1ef72c33 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Tue, 29 Apr 2025 12:41:30 -0400
Subject: [PATCH 034/143] More cleaning

---
 pyomo/contrib/doe/doe.py | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index 8151db9810b..07138f34f5d 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -415,9 +415,6 @@ def run_doe(self, model=None, results_file=None):
         # Solve the full model, which has now been initialized with the square solve
         if self.use_grey_box:
             res = self.grey_box_solver.solve(model, tee=self.tee)
-            # from idaes.core.util import DiagnosticsToolbox
-            # dt = DiagnosticsToolbox(model)
-            # dt.report_numerical_issues()
         else:
             res = self.solver.solve(model, tee=self.tee)
 

From aee4ef8674d1ee7488688b40c0a5e97c1baae4f7 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Tue, 29 Apr 2025 12:45:09 -0400
Subject: [PATCH 035/143] Ran Black.

---
 pyomo/contrib/doe/doe.py | 29 ++++++++++++-----------------
 1 file changed, 12 insertions(+), 17 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index 07138f34f5d..e70b759bc47 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -305,11 +305,11 @@ def run_doe(self, model=None, results_file=None):
             "Successfully built the DoE model.\nBuild time: %0.1f seconds" % build_time
         )
 
-        # Solve the square problem first to 
+        # Solve the square problem first to
         # initialize the fim and
         # sensitivity constraints. First, we
-        # Deactivate objective expression and 
-        # objective constraints (on a block), 
+        # Deactivate objective expression and
+        # objective constraints (on a block),
         # and fix the design variables.
         model.objective.deactivate()
         model.obj_cons.deactivate()
@@ -1381,23 +1381,21 @@ def create_grey_box_objective_function(self, model=None):
         # reuse material for initializing the objective-free square model
         if model is None:
             model = model = self.model
-        
+
         # ToDo: Make this naming convention robust
         model.obj_cons = pyo.Block()
-        
+
         # Create FIM External Grey Box object
         grey_box_FIM = FIMExternalGreyBox(
             doe_object=self,
             objective_option=self.objective_option,
             logger_level=self.logger.getEffectiveLevel(),
         )
-        
+
         # Attach External Grey Box Model
-        # to the model as an External 
+        # to the model as an External
         # Grey Box Block
-        model.obj_cons.egb_fim_block = ExternalGreyBoxBlock(
-            external_model=grey_box_FIM
-        )
+        model.obj_cons.egb_fim_block = ExternalGreyBoxBlock(external_model=grey_box_FIM)
 
         # Adding constraints to for all grey box input values to equate to fim values
         def FIM_egb_cons(m, p1, p2):
@@ -1417,7 +1415,7 @@ def FIM_egb_cons(m, p1, p2):
             else:
                 return pyo.Constraint.Skip
 
-        # Add the FIM and External Grey 
+        # Add the FIM and External Grey
         # Box inputs constraints
         model.obj_cons.FIM_equalities = pyo.Constraint(
             model.parameter_names, model.parameter_names, rule=FIM_egb_cons
@@ -1427,8 +1425,7 @@ def FIM_egb_cons(m, p1, p2):
         # type within ObjectiveLib
         if self.objective_option == ObjectiveLib.trace:
             model.objective = pyo.Objective(
-                expr=model.obj_cons.egb_fim_block.outputs["A-opt"],
-                sense=pyo.minimize,
+                expr=model.obj_cons.egb_fim_block.outputs["A-opt"], sense=pyo.minimize
             )
         elif self.objective_option == ObjectiveLib.determinant:
             model.objective = pyo.Objective(
@@ -1437,13 +1434,11 @@ def FIM_egb_cons(m, p1, p2):
             )
         elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
             model.objective = pyo.Objective(
-                expr=model.obj_cons.egb_fim_block.outputs["E-opt"],
-                sense=pyo.maximize,
+                expr=model.obj_cons.egb_fim_block.outputs["E-opt"], sense=pyo.maximize
             )
         elif self.objective_option == ObjectiveLib.condition_number:
             model.objective = pyo.Objective(
-                expr=model.obj_cons.egb_fim_block.outputs["ME-opt"],
-                sense=pyo.minimize,
+                expr=model.obj_cons.egb_fim_block.outputs["ME-opt"], sense=pyo.minimize
             )
         else:
             raise AttributeError(

From e4c7239b7da7037765c568cc817d6177d3737eb6 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Tue, 29 Apr 2025 15:18:06 -0400
Subject: [PATCH 036/143] Using MUMPS as solver for now

---
 pyomo/contrib/doe/doe.py                      | 22 +++++++++++++------
 .../doe/examples/grey_box_D_opt_comparison.py |  3 +++
 2 files changed, 18 insertions(+), 7 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index e70b759bc47..1dee35b076d 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -207,8 +207,8 @@ def __init__(
         # if not given, use default solver
         else:
             solver = pyo.SolverFactory("ipopt")
-            solver.options["linear_solver"] = "ma57"
-            # solver.options["linear_solver"] = "MUMPS"
+            # solver.options["linear_solver"] = "ma57"
+            solver.options["linear_solver"] = "MUMPS"
             solver.options["halt_on_ampl_error"] = "yes"
             solver.options["max_iter"] = 3000
             # solver.options["tol"] = 1e-4
@@ -222,7 +222,7 @@ def __init__(
         else:
             grey_box_solver = pyo.SolverFactory("cyipopt")
             grey_box_solver.config.options['hessian_approximation'] = 'limited-memory'
-            grey_box_solver.config.options["linear_solver"] = "ma57"
+            # grey_box_solver.config.options["linear_solver"] = "ma57"
             grey_box_solver.config.options['max_iter'] = 200
             grey_box_solver.config.options['tol'] = 1e-4
             # grey_box_solver.config.options['mu_strategy'] = "monotone"
@@ -351,12 +351,20 @@ def run_doe(self, model=None, results_file=None):
                         model.obj_cons.egb_fim_block.inputs[(j, i)].set_value(
                             pyo.value(model.fim[(i, j)])
                         )
+                        print(j, i)
                     else:  # REMOVE THIS IF USING LOWER TRIANGLE
-                        model.obj_cons.egb_fim_block.inputs[(j, i)].set_value(
-                            pyo.value(model.fim[(j, i)])
-                        )
+                        pass
+                        #model.obj_cons.egb_fim_block.inputs[(j, i)].set_value(
+                        #    pyo.value(model.fim[(j, i)])
+                        #)
             # Set objective value
-            if self.objective_option == ObjectiveLib.determinant:
+            if self.objective_option == ObjectiveLib.trace:
+                # Do safe inverse here?
+                trace_val = 1 / np.trace(np.array(self.get_FIM()))
+                model.obj_cons.egb_fim_block.outputs["A-opt"].set_value(
+                    trace_val
+                )
+            elif self.objective_option == ObjectiveLib.determinant:
                 det_val = np.linalg.det(np.array(self.get_FIM()))
                 model.obj_cons.egb_fim_block.outputs["log10-D-opt"].set_value(
                     np.log(det_val)
diff --git a/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py b/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
index f4b53a6ed80..3122beba371 100644
--- a/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
+++ b/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
@@ -186,6 +186,9 @@ def compare_reactor_doe():
 
     print(doe_obj.results["Experiment Design Names"])
 
+    print(dir(doe_obj_grey_box.model.obj_cons.egb_fim_block))
+    doe_obj_grey_box.model.obj_cons.egb_fim_block._input_names_set.pprint()
+
 
 if __name__ == "__main__":
     compare_reactor_doe()

From 1f23a3037b88c85ab500a30800f75fda2631b338 Mon Sep 17 00:00:00 2001
From: djalky <dlakes94@gmail.com>
Date: Wed, 14 May 2025 08:54:47 -0400
Subject: [PATCH 037/143] tracking down non-determinism of grey box

---
 .../examples/example_greybox_determinism.py   | 109 ++++++++++++++++++
 1 file changed, 109 insertions(+)
 create mode 100644 pyomo/contrib/doe/examples/example_greybox_determinism.py

diff --git a/pyomo/contrib/doe/examples/example_greybox_determinism.py b/pyomo/contrib/doe/examples/example_greybox_determinism.py
new file mode 100644
index 00000000000..27d67cdc1bc
--- /dev/null
+++ b/pyomo/contrib/doe/examples/example_greybox_determinism.py
@@ -0,0 +1,109 @@
+
+
+
+class FIMExternalGreyBox(ExternalGreyBoxModel):
+    def __init__(self, ):
+        """
+        Grey box model for metrics on the FIM. This methodology reduces numerical complexity for the
+        computation of FIM metrics related to eigenvalue decomposition.
+
+        Parameters
+        ----------
+        doe_object:
+           Design of Experiments object that contains a built model (with sensitivity matrix, Q, and
+           fisher information matrix, FIM). The external grey box model will utilize elements of the
+           doe_object's model to build the FIM metric with consistent naming.
+        obj_option:
+           String representation of the objective option. Current available option is ``determinant``.
+           Other options that are planned to be implemented soon are ``minimum_eig`` (E-optimality),
+           and ``condition_number`` (modified E-optimality). default option is ``determinant``
+        logger_level:
+           logging level to be specified if different from doe_object's logging level. default value
+           is None, or equivalently, use the logging level of doe_object. Use logging.DEBUG for all
+           messages.
+        """
+        # Grab parameter list from the doe_object model
+        self._param_names = [i for i in self.doe_object.model.parameter_names]
+        self._n_params = len(self._param_names)
+
+        self._n_inputs = len(self._input_values)
+        # print(self._input_values)
+
+    def input_names(self):
+        # Cartesian product gives us matrix indices flattened in row-first format
+        # Can use itertools.combinations(self._param_names, 2) with added
+        # diagonal elements, or do double for loops if we switch to upper triangular
+        # input_names_list = list(itertools.product(self._param_names, self._param_names))
+        input_names_list = list(
+            itertools.combinations_with_replacement(self._param_names, 2)
+        )
+        return input_names_list
+
+    def equality_constraint_names(self):
+        # ToDo: Are there any objectives that will have constraints?
+        return []
+
+    def output_names(self):
+        # ToDo: add output name for the variable. This may have to be
+        # an input from the user. Or it could depend on the usage of
+        # the ObjectiveLib Enum object, which should have an associated
+        # name for the objective function at all times.
+        
+        return ["obj", ]
+
+    def set_input_values(self, input_values):
+        # Set initial values to be flattened initial FIM (aligns with input names)
+        np.copyto(self._input_values, input_values)
+        # self._input_values = list(self.doe_object.fim_initial.flatten())
+
+    def evaluate_equality_constraints(self):
+        # ToDo: are there any objectives that will have constraints?
+        return None
+
+    def evaluate_outputs(self):
+        # Evaluates the objective value for the specified
+        # ObjectiveLib type.
+        
+        return np.asarray([obj_value], dtype=np.float64)
+
+    def finalize_block_construction(self, pyomo_block):
+        # Set bounds on the inputs/outputs
+        # Set initial values of the inputs/outputs
+        # This will depend on the objective used
+
+        # Initialize grey box FIM values
+        for ind, val in enumerate(self.input_names()):
+            pyomo_block.inputs[val] = self.doe_object.fim_initial.flatten()[ind]
+
+    def evaluate_jacobian_equality_constraints(self):
+        # ToDo: Do any objectives require constraints?
+
+        # Returns coo_matrix of the correct shape
+        return None
+
+    def evaluate_jacobian_outputs(self):
+        # Compute the jacobian of the objective function with
+        # respect to the fisher information matrix. Then return
+        # a coo_matrix that aligns with what IPOPT will expect.
+        #
+        # ToDo: there will be significant bookkeeping for more
+        # complicated objective functions and the Hessian
+        
+        return coo_matrix(
+            (jac_M.flatten(), (M_rows, M_cols)), shape=(1, len(jac_M.flatten()))
+        )
+
+    # Beyond here is for Hessian information
+    def set_equality_constraint_multipliers(self, eq_con_multiplier_values):
+        # ToDo: Do any objectives require constraints?
+        # Assert lengths match
+        self._eq_con_mult_values = np.asarray(
+            eq_con_multiplier_values, dtype=np.float64
+        )
+
+    def set_output_constraint_multipliers(self, output_con_multiplier_values):
+        # ToDo: Do any objectives require constraints?
+        # Assert length matches
+        self._output_con_mult_values = np.asarray(
+            output_con_multiplier_values, dtype=np.float64
+        )
\ No newline at end of file

From 2c1375f5d322d9c060f343ed758eb9b3aa2b2d6b Mon Sep 17 00:00:00 2001
From: djalky <dlakes94@gmail.com>
Date: Wed, 14 May 2025 09:55:48 -0400
Subject: [PATCH 038/143] Updated simple grey box case study.

---
 .../examples/example_greybox_determinism.py   | 47 ++++++++++++++-----
 1 file changed, 35 insertions(+), 12 deletions(-)

diff --git a/pyomo/contrib/doe/examples/example_greybox_determinism.py b/pyomo/contrib/doe/examples/example_greybox_determinism.py
index 27d67cdc1bc..52d6cb340d5 100644
--- a/pyomo/contrib/doe/examples/example_greybox_determinism.py
+++ b/pyomo/contrib/doe/examples/example_greybox_determinism.py
@@ -1,8 +1,15 @@
+from scipy.sparse import coo_matrix
 
+from pyomo.common.dependencies import numpy as np
 
+from pyomo.contrib.pynumero.interfaces.external_grey_box import ExternalGreyBoxModel
+from pyomo.contrib.pynumero.interfaces.external_grey_box import ExternalGreyBoxBlock
 
-class FIMExternalGreyBox(ExternalGreyBoxModel):
-    def __init__(self, ):
+import pyomo.environ as pyo
+
+
+class SumEGB(ExternalGreyBoxModel):
+    def __init__(self, n_inputs):
         """
         Grey box model for metrics on the FIM. This methodology reduces numerical complexity for the
         computation of FIM metrics related to eigenvalue decomposition.
@@ -22,10 +29,10 @@ def __init__(self, ):
            is None, or equivalently, use the logging level of doe_object. Use logging.DEBUG for all
            messages.
         """
-        # Grab parameter list from the doe_object model
-        self._param_names = [i for i in self.doe_object.model.parameter_names]
-        self._n_params = len(self._param_names)
-
+        self._n_inputs = n_inputs
+        
+        self._input_names_list = ["x_" + str(i) for i in range(self._n_inputs)]
+        
         self._n_inputs = len(self._input_values)
         # print(self._input_values)
 
@@ -34,10 +41,7 @@ def input_names(self):
         # Can use itertools.combinations(self._param_names, 2) with added
         # diagonal elements, or do double for loops if we switch to upper triangular
         # input_names_list = list(itertools.product(self._param_names, self._param_names))
-        input_names_list = list(
-            itertools.combinations_with_replacement(self._param_names, 2)
-        )
-        return input_names_list
+        return self._inputs_names_list
 
     def equality_constraint_names(self):
         # ToDo: Are there any objectives that will have constraints?
@@ -73,7 +77,11 @@ def finalize_block_construction(self, pyomo_block):
 
         # Initialize grey box FIM values
         for ind, val in enumerate(self.input_names()):
-            pyomo_block.inputs[val] = self.doe_object.fim_initial.flatten()[ind]
+            pyomo_block.inputs[val] = ind
+            pyomo_block.inputs[val].setlb(0)
+            pyomo_block.inputs[val].setub(20)
+        
+        pyomo_block.outputs["obj"] = sum(range(n_inputs))
 
     def evaluate_jacobian_equality_constraints(self):
         # ToDo: Do any objectives require constraints?
@@ -89,6 +97,10 @@ def evaluate_jacobian_outputs(self):
         # ToDo: there will be significant bookkeeping for more
         # complicated objective functions and the Hessian
         
+        jac_M = np.eye(self._n_inputs)
+        M_rows = np.zeros((len(jac_M.flatten()), 1)).flatten()
+        M_cols = np.arange(len(jac_M.flatten()))
+        
         return coo_matrix(
             (jac_M.flatten(), (M_rows, M_cols)), shape=(1, len(jac_M.flatten()))
         )
@@ -106,4 +118,15 @@ def set_output_constraint_multipliers(self, output_con_multiplier_values):
         # Assert length matches
         self._output_con_mult_values = np.asarray(
             output_con_multiplier_values, dtype=np.float64
-        )
\ No newline at end of file
+        )
+
+
+# Simple grey box problem to test determinism.
+m = pyo.ConcreteModel()
+
+grey_box = SumEGB(5)
+
+m.egb_block = ExternalGreyBoxBlock(external_model=grey_box)
+
+solver = pyo.SolverFactory("cyipopt")
+solver.solve(m, tee=True)
\ No newline at end of file

From ab7b16cada800239daf598ea2ed13d1a74bd3718 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 06:56:13 -0400
Subject: [PATCH 039/143] Removing grey box determinism file

Moved this to an alternate place. The pull requests will be separate.
---
 .../examples/example_greybox_determinism.py   | 132 ------------------
 1 file changed, 132 deletions(-)
 delete mode 100644 pyomo/contrib/doe/examples/example_greybox_determinism.py

diff --git a/pyomo/contrib/doe/examples/example_greybox_determinism.py b/pyomo/contrib/doe/examples/example_greybox_determinism.py
deleted file mode 100644
index 52d6cb340d5..00000000000
--- a/pyomo/contrib/doe/examples/example_greybox_determinism.py
+++ /dev/null
@@ -1,132 +0,0 @@
-from scipy.sparse import coo_matrix
-
-from pyomo.common.dependencies import numpy as np
-
-from pyomo.contrib.pynumero.interfaces.external_grey_box import ExternalGreyBoxModel
-from pyomo.contrib.pynumero.interfaces.external_grey_box import ExternalGreyBoxBlock
-
-import pyomo.environ as pyo
-
-
-class SumEGB(ExternalGreyBoxModel):
-    def __init__(self, n_inputs):
-        """
-        Grey box model for metrics on the FIM. This methodology reduces numerical complexity for the
-        computation of FIM metrics related to eigenvalue decomposition.
-
-        Parameters
-        ----------
-        doe_object:
-           Design of Experiments object that contains a built model (with sensitivity matrix, Q, and
-           fisher information matrix, FIM). The external grey box model will utilize elements of the
-           doe_object's model to build the FIM metric with consistent naming.
-        obj_option:
-           String representation of the objective option. Current available option is ``determinant``.
-           Other options that are planned to be implemented soon are ``minimum_eig`` (E-optimality),
-           and ``condition_number`` (modified E-optimality). default option is ``determinant``
-        logger_level:
-           logging level to be specified if different from doe_object's logging level. default value
-           is None, or equivalently, use the logging level of doe_object. Use logging.DEBUG for all
-           messages.
-        """
-        self._n_inputs = n_inputs
-        
-        self._input_names_list = ["x_" + str(i) for i in range(self._n_inputs)]
-        
-        self._n_inputs = len(self._input_values)
-        # print(self._input_values)
-
-    def input_names(self):
-        # Cartesian product gives us matrix indices flattened in row-first format
-        # Can use itertools.combinations(self._param_names, 2) with added
-        # diagonal elements, or do double for loops if we switch to upper triangular
-        # input_names_list = list(itertools.product(self._param_names, self._param_names))
-        return self._inputs_names_list
-
-    def equality_constraint_names(self):
-        # ToDo: Are there any objectives that will have constraints?
-        return []
-
-    def output_names(self):
-        # ToDo: add output name for the variable. This may have to be
-        # an input from the user. Or it could depend on the usage of
-        # the ObjectiveLib Enum object, which should have an associated
-        # name for the objective function at all times.
-        
-        return ["obj", ]
-
-    def set_input_values(self, input_values):
-        # Set initial values to be flattened initial FIM (aligns with input names)
-        np.copyto(self._input_values, input_values)
-        # self._input_values = list(self.doe_object.fim_initial.flatten())
-
-    def evaluate_equality_constraints(self):
-        # ToDo: are there any objectives that will have constraints?
-        return None
-
-    def evaluate_outputs(self):
-        # Evaluates the objective value for the specified
-        # ObjectiveLib type.
-        
-        return np.asarray([obj_value], dtype=np.float64)
-
-    def finalize_block_construction(self, pyomo_block):
-        # Set bounds on the inputs/outputs
-        # Set initial values of the inputs/outputs
-        # This will depend on the objective used
-
-        # Initialize grey box FIM values
-        for ind, val in enumerate(self.input_names()):
-            pyomo_block.inputs[val] = ind
-            pyomo_block.inputs[val].setlb(0)
-            pyomo_block.inputs[val].setub(20)
-        
-        pyomo_block.outputs["obj"] = sum(range(n_inputs))
-
-    def evaluate_jacobian_equality_constraints(self):
-        # ToDo: Do any objectives require constraints?
-
-        # Returns coo_matrix of the correct shape
-        return None
-
-    def evaluate_jacobian_outputs(self):
-        # Compute the jacobian of the objective function with
-        # respect to the fisher information matrix. Then return
-        # a coo_matrix that aligns with what IPOPT will expect.
-        #
-        # ToDo: there will be significant bookkeeping for more
-        # complicated objective functions and the Hessian
-        
-        jac_M = np.eye(self._n_inputs)
-        M_rows = np.zeros((len(jac_M.flatten()), 1)).flatten()
-        M_cols = np.arange(len(jac_M.flatten()))
-        
-        return coo_matrix(
-            (jac_M.flatten(), (M_rows, M_cols)), shape=(1, len(jac_M.flatten()))
-        )
-
-    # Beyond here is for Hessian information
-    def set_equality_constraint_multipliers(self, eq_con_multiplier_values):
-        # ToDo: Do any objectives require constraints?
-        # Assert lengths match
-        self._eq_con_mult_values = np.asarray(
-            eq_con_multiplier_values, dtype=np.float64
-        )
-
-    def set_output_constraint_multipliers(self, output_con_multiplier_values):
-        # ToDo: Do any objectives require constraints?
-        # Assert length matches
-        self._output_con_mult_values = np.asarray(
-            output_con_multiplier_values, dtype=np.float64
-        )
-
-
-# Simple grey box problem to test determinism.
-m = pyo.ConcreteModel()
-
-grey_box = SumEGB(5)
-
-m.egb_block = ExternalGreyBoxBlock(external_model=grey_box)
-
-solver = pyo.SolverFactory("cyipopt")
-solver.solve(m, tee=True)
\ No newline at end of file

From f9548bf00e5ad87fa5df5b38df9260371c0793a8 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 07:12:05 -0400
Subject: [PATCH 040/143] Changed D-opt name, added A-opt to naming

---
 pyomo/contrib/doe/grey_box_utilities.py | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index f41e515712d..ca3a6d3e280 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -140,8 +140,10 @@ def output_names(self):
         # name for the objective function at all times.
         from pyomo.contrib.doe import ObjectiveLib
 
-        if self.objective_option == ObjectiveLib.determinant:
-            obj_name = "log10-D-opt"
+        if self.objective_option == ObjectiveLib.trace:
+            obj_name = "A-opt"
+        elif self.objective_option == ObjectiveLib.determinant:
+            obj_name = "log-D-opt"
         elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
             obj_name = "E-opt"
         elif self.objective_option == ObjectiveLib.condition_number:
@@ -201,7 +203,7 @@ def finalize_block_construction(self, pyomo_block):
         if self.objective_option == ObjectiveLib.trace:
             pyomo_block.outputs["A-opt"] = 0
         elif self.objective_option == ObjectiveLib.determinant:
-            pyomo_block.outputs["log10-D-opt"] = 0
+            pyomo_block.outputs["log-D-opt"] = 0
         elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
             pyomo_block.outputs["E-opt"] = 0
         elif self.objective_option == ObjectiveLib.condition_number:

From 863c2454acf2c781a2152a6da789ae955bd2420a Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 07:23:01 -0400
Subject: [PATCH 041/143] Set default solver back to ma57

MUMPS fails to converge on some tests.
---
 pyomo/contrib/doe/doe.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index 1dee35b076d..e5df363261f 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -207,8 +207,8 @@ def __init__(
         # if not given, use default solver
         else:
             solver = pyo.SolverFactory("ipopt")
-            # solver.options["linear_solver"] = "ma57"
-            solver.options["linear_solver"] = "MUMPS"
+            solver.options["linear_solver"] = "ma57"
+            # solver.options["linear_solver"] = "MUMPS"
             solver.options["halt_on_ampl_error"] = "yes"
             solver.options["max_iter"] = 3000
             # solver.options["tol"] = 1e-4

From 4a3b31011ca53931276618940964915e8d51b632 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 07:23:14 -0400
Subject: [PATCH 042/143] Add input/output name testing

---
 pyomo/contrib/doe/tests/test_greybox.py | 61 +++++++++++++++++++++++++
 1 file changed, 61 insertions(+)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index bf5eb3f29da..5e422533b8d 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -307,6 +307,67 @@ def test_set_inputs(self):
         grey_box_FIM = grey_box_object._get_FIM()
 
         self.assertTrue(np.all(np.isclose(grey_box_FIM, testing_matrix)))
+    
+    # Testing that getting the
+    # input names works properly
+    def test_input_names(self):
+        objective_option = "trace"
+        doe_obj, grey_box_object = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
+
+        # Hard-coded names of the inputs, in the order we expect
+        input_names = [('A1', 'A1'), ('A1', 'A2'), ('A1', 'E1'), 
+                       ('A1', 'E2'), ('A2', 'A2'), ('A2', 'E1'),
+                       ('A2', 'E2'), ('E1', 'E1'), ('E1', 'E2'),
+                       ('E2', 'E2')]
+        
+        # Grabbing input names from grey box object
+        input_names_gb = grey_box_object.input_names()
+
+        self.assertListEqual(input_names, input_names_gb)
+    
+    # Testing that getting the
+    # output names works properly
+    def test_input_names(self):
+        # Need to test for each objective type
+        # A-opt
+        objective_option = "trace"
+        doe_obj_A, grey_box_object_A = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
+
+        # D-opt
+        objective_option = "determinant"
+        doe_obj_D, grey_box_object_D = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
+
+        # E-opt
+        objective_option = "minimum_eigenvalue"
+        doe_obj_E, grey_box_object_E = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
+
+        # ME-opt
+        objective_option = "condition_number"
+        doe_obj_ME, grey_box_object_ME = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
+
+        # Hard-coded names of the outputs
+        # There is one element per 
+        # objective type
+        output_names = ['A-opt', 'log-D-opt', 'E-opt', 'ME-opt']
+        
+        # Grabbing input names from grey box object
+        output_names_gb = []
+        output_names_gb.extend(grey_box_object_A.output_names())
+        output_names_gb.extend(grey_box_object_D.output_names())
+        output_names_gb.extend(grey_box_object_E.output_names())
+        output_names_gb.extend(grey_box_object_ME.output_names())
+
+        self.assertListEqual(output_names, output_names_gb)
 
     # Testing output computation
     def test_outputs_A_opt(self):

From cad480e7439bc8ac742e9faf83f01137e7ba7f32 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 07:24:21 -0400
Subject: [PATCH 043/143] Ran black

---
 pyomo/contrib/doe/doe.py                |  8 +++-----
 pyomo/contrib/doe/tests/test_greybox.py | 26 ++++++++++++++++---------
 2 files changed, 20 insertions(+), 14 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index e5df363261f..2a04eeab186 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -354,16 +354,14 @@ def run_doe(self, model=None, results_file=None):
                         print(j, i)
                     else:  # REMOVE THIS IF USING LOWER TRIANGLE
                         pass
-                        #model.obj_cons.egb_fim_block.inputs[(j, i)].set_value(
+                        # model.obj_cons.egb_fim_block.inputs[(j, i)].set_value(
                         #    pyo.value(model.fim[(j, i)])
-                        #)
+                        # )
             # Set objective value
             if self.objective_option == ObjectiveLib.trace:
                 # Do safe inverse here?
                 trace_val = 1 / np.trace(np.array(self.get_FIM()))
-                model.obj_cons.egb_fim_block.outputs["A-opt"].set_value(
-                    trace_val
-                )
+                model.obj_cons.egb_fim_block.outputs["A-opt"].set_value(trace_val)
             elif self.objective_option == ObjectiveLib.determinant:
                 det_val = np.linalg.det(np.array(self.get_FIM()))
                 model.obj_cons.egb_fim_block.outputs["log10-D-opt"].set_value(
diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 5e422533b8d..7c474435695 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -307,7 +307,7 @@ def test_set_inputs(self):
         grey_box_FIM = grey_box_object._get_FIM()
 
         self.assertTrue(np.all(np.isclose(grey_box_FIM, testing_matrix)))
-    
+
     # Testing that getting the
     # input names works properly
     def test_input_names(self):
@@ -317,16 +317,24 @@ def test_input_names(self):
         )
 
         # Hard-coded names of the inputs, in the order we expect
-        input_names = [('A1', 'A1'), ('A1', 'A2'), ('A1', 'E1'), 
-                       ('A1', 'E2'), ('A2', 'A2'), ('A2', 'E1'),
-                       ('A2', 'E2'), ('E1', 'E1'), ('E1', 'E2'),
-                       ('E2', 'E2')]
-        
+        input_names = [
+            ('A1', 'A1'),
+            ('A1', 'A2'),
+            ('A1', 'E1'),
+            ('A1', 'E2'),
+            ('A2', 'A2'),
+            ('A2', 'E1'),
+            ('A2', 'E2'),
+            ('E1', 'E1'),
+            ('E1', 'E2'),
+            ('E2', 'E2'),
+        ]
+
         # Grabbing input names from grey box object
         input_names_gb = grey_box_object.input_names()
 
         self.assertListEqual(input_names, input_names_gb)
-    
+
     # Testing that getting the
     # output names works properly
     def test_input_names(self):
@@ -356,10 +364,10 @@ def test_input_names(self):
         )
 
         # Hard-coded names of the outputs
-        # There is one element per 
+        # There is one element per
         # objective type
         output_names = ['A-opt', 'log-D-opt', 'E-opt', 'ME-opt']
-        
+
         # Grabbing input names from grey box object
         output_names_gb = []
         output_names_gb.extend(grey_box_object_A.output_names())

From cf8a1a03a3128f11a772f4de6536c554ebaa58d7 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 07:28:19 -0400
Subject: [PATCH 044/143] Update D-opt name in doe.py file

---
 pyomo/contrib/doe/doe.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index 2a04eeab186..fc490a3d5d7 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -364,7 +364,7 @@ def run_doe(self, model=None, results_file=None):
                 model.obj_cons.egb_fim_block.outputs["A-opt"].set_value(trace_val)
             elif self.objective_option == ObjectiveLib.determinant:
                 det_val = np.linalg.det(np.array(self.get_FIM()))
-                model.obj_cons.egb_fim_block.outputs["log10-D-opt"].set_value(
+                model.obj_cons.egb_fim_block.outputs["log-D-opt"].set_value(
                     np.log(det_val)
                 )
             elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
@@ -1435,7 +1435,7 @@ def FIM_egb_cons(m, p1, p2):
             )
         elif self.objective_option == ObjectiveLib.determinant:
             model.objective = pyo.Objective(
-                expr=model.obj_cons.egb_fim_block.outputs["log10-D-opt"],
+                expr=model.obj_cons.egb_fim_block.outputs["log-D-opt"],
                 sense=pyo.maximize,
             )
         elif self.objective_option == ObjectiveLib.minimum_eigenvalue:

From cef85c7d111fe02dd73a3cf6dfe742be216e8f9e Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 07:45:35 -0400
Subject: [PATCH 045/143] Fixed test naming to not overwrite input test

---
 pyomo/contrib/doe/tests/test_greybox.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 7c474435695..bb1698c2e33 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -337,7 +337,7 @@ def test_input_names(self):
 
     # Testing that getting the
     # output names works properly
-    def test_input_names(self):
+    def test_output_names(self):
         # Need to test for each objective type
         # A-opt
         objective_option = "trace"

From 46b929be15915cdeb34b9c52ce39f146aeff7d4c Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 08:03:32 -0400
Subject: [PATCH 046/143] Better output initialization for greybox

---
 pyomo/contrib/doe/grey_box_utilities.py | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index ca3a6d3e280..70efca2c5e1 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -200,14 +200,19 @@ def finalize_block_construction(self, pyomo_block):
         # Initialize log_determinant value
         from pyomo.contrib.doe import ObjectiveLib
 
+        # Calculate initial values for the output
+        output_value = self.evaluate_outputs()[0]
+        
+        # Set the value of the output for the given
+        # objective function.
         if self.objective_option == ObjectiveLib.trace:
-            pyomo_block.outputs["A-opt"] = 0
+            pyomo_block.outputs["A-opt"] = output_value
         elif self.objective_option == ObjectiveLib.determinant:
-            pyomo_block.outputs["log-D-opt"] = 0
+            pyomo_block.outputs["log-D-opt"] = output_value
         elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
-            pyomo_block.outputs["E-opt"] = 0
+            pyomo_block.outputs["E-opt"] = output_value
         elif self.objective_option == ObjectiveLib.condition_number:
-            pyomo_block.outputs["ME-opt"] = 0
+            pyomo_block.outputs["ME-opt"] = output_value
 
     def evaluate_jacobian_equality_constraints(self):
         # ToDo: Do any objectives require constraints?

From cb45414bf3ac03240407a4c55a018661854dfab1 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 08:03:54 -0400
Subject: [PATCH 047/143] Ran black

---
 pyomo/contrib/doe/grey_box_utilities.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index 70efca2c5e1..548a3175694 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -202,7 +202,7 @@ def finalize_block_construction(self, pyomo_block):
 
         # Calculate initial values for the output
         output_value = self.evaluate_outputs()[0]
-        
+
         # Set the value of the output for the given
         # objective function.
         if self.objective_option == ObjectiveLib.trace:

From 5be3e0b35482eb0328f037b233d0632a075154c9 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 09:15:30 -0400
Subject: [PATCH 048/143] Add a few more tests

---
 pyomo/contrib/doe/grey_box_utilities.py |  8 ++--
 pyomo/contrib/doe/tests/test_greybox.py | 54 +++++++++++++++++++++++++
 2 files changed, 58 insertions(+), 4 deletions(-)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index 548a3175694..358ccd7420f 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -353,10 +353,10 @@ def set_output_constraint_multipliers(self, output_con_multiplier_values):
             output_con_multiplier_values, dtype=np.float64
         )
 
-    # def evaluate_hessian_equality_constraints(self):
-    #     #ToDo: Do any objectives require constraints?
-    #     #Returns coo_matrix of the correct shape
-    #     return None
+    def evaluate_hessian_equality_constraints(self):
+        # Returns coo_matrix of the correct shape
+        # No constraints so this returns `None`
+        return None
 
     # def evaluate_hessian_outputs(self, FIM=None):
     #     # ToDo: significant bookkeeping if the hessian's require vectorized
diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index bb1698c2e33..75f53f9b0ea 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -531,6 +531,60 @@ def test_jacobian_ME_opt(self):
 
         # assert that each component is close
         self.assertTrue(np.all(np.isclose(jac, jac_FD)))
+    
+    def test_equality_constraint_names(self):
+        objective_option = "condition_number"
+        doe_obj, grey_box_object = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
+
+        # Grab equality constraint names
+        eq_con_names_gb = grey_box_object.equality_constraint_names()
+
+        # Equality constraint names should be an
+        # empty list.
+        self.assertListEqual(eq_con_names_gb, [])
+    
+    def test_evaluate_equality_constraints(self):
+        objective_option = "condition_number"
+        doe_obj, grey_box_object = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
+
+        # Grab equality constraint names
+        eq_con_vals_gb = grey_box_object.evaluate_equality_constraints()
+
+        # Equality constraint values should be `None`
+        # There are no equality constraints.
+        self.assertIsNone(eq_con_vals_gb)
+    
+    def test_evaluate_jacobian_equality_constraints(self):
+        objective_option = "condition_number"
+        doe_obj, grey_box_object = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
+
+        # Grab equality constraint names
+        jac_eq_con_vals_gb = grey_box_object.evaluate_jacobian_equality_constraints()
+
+        # Jacobian of equality constraints
+        # should be `None` as there are no
+        # equality constraints
+        self.assertIsNone(jac_eq_con_vals_gb)
+    
+    def evaluate_hessian_equality_constraints(self):
+        objective_option = "condition_number"
+        doe_obj, grey_box_object = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
+
+        # Grab equality constraint names
+        hess_eq_con_vals_gb = grey_box_object.evaluate_hessian_equality_constraints()
+
+        # Jacobian of equality constraints
+        # should be `None` as there are no
+        # equality constraints
+        self.assertIsNone(hess_eq_con_vals_gb)
 
 
 if __name__ == "__main__":

From f6c364e287beae12a5a0aa494df6df60dab4624a Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 09:15:45 -0400
Subject: [PATCH 049/143] Ran black

---
 pyomo/contrib/doe/tests/test_greybox.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 75f53f9b0ea..da54b2d81e7 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -531,7 +531,7 @@ def test_jacobian_ME_opt(self):
 
         # assert that each component is close
         self.assertTrue(np.all(np.isclose(jac, jac_FD)))
-    
+
     def test_equality_constraint_names(self):
         objective_option = "condition_number"
         doe_obj, grey_box_object = make_greybox_and_doe_objects(
@@ -544,7 +544,7 @@ def test_equality_constraint_names(self):
         # Equality constraint names should be an
         # empty list.
         self.assertListEqual(eq_con_names_gb, [])
-    
+
     def test_evaluate_equality_constraints(self):
         objective_option = "condition_number"
         doe_obj, grey_box_object = make_greybox_and_doe_objects(
@@ -557,7 +557,7 @@ def test_evaluate_equality_constraints(self):
         # Equality constraint values should be `None`
         # There are no equality constraints.
         self.assertIsNone(eq_con_vals_gb)
-    
+
     def test_evaluate_jacobian_equality_constraints(self):
         objective_option = "condition_number"
         doe_obj, grey_box_object = make_greybox_and_doe_objects(
@@ -571,7 +571,7 @@ def test_evaluate_jacobian_equality_constraints(self):
         # should be `None` as there are no
         # equality constraints
         self.assertIsNone(jac_eq_con_vals_gb)
-    
+
     def evaluate_hessian_equality_constraints(self):
         objective_option = "condition_number"
         doe_obj, grey_box_object = make_greybox_and_doe_objects(

From 7f77ec5b26e7e72fd5a561dc541ca66bd2e018bd Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 09:24:39 -0400
Subject: [PATCH 050/143] Fixed misnamed test.

---
 pyomo/contrib/doe/tests/test_greybox.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index da54b2d81e7..389cf7ecd5d 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -572,7 +572,7 @@ def test_evaluate_jacobian_equality_constraints(self):
         # equality constraints
         self.assertIsNone(jac_eq_con_vals_gb)
 
-    def evaluate_hessian_equality_constraints(self):
+    def test_evaluate_hessian_equality_constraints(self):
         objective_option = "condition_number"
         doe_obj, grey_box_object = make_greybox_and_doe_objects(
             objective_option=objective_option

From b2963c5f3f3f38a69e0290bbe07a3801eefa9fc4 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 10:01:34 -0400
Subject: [PATCH 051/143] Checkpoint - trying to add build tests

---
 pyomo/contrib/doe/grey_box_utilities.py |  1 +
 pyomo/contrib/doe/tests/test_greybox.py | 62 +++++++++++++++++++++++++
 2 files changed, 63 insertions(+)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index 358ccd7420f..ccc84121ac0 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -98,6 +98,7 @@ def __init__(self, doe_object, objective_option="determinant", logger_level=None
         self._input_values = np.asarray(
             self.doe_object.fim_initial[self._masking_matrix > 0], dtype=np.float64
         )
+        print(self.doe_object.fim_initial[self._masking_matrix > 0])
         self._n_inputs = len(self._input_values)
         # print(self._input_values)
 
diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 389cf7ecd5d..bc1b085d10d 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -277,6 +277,7 @@ def make_greybox_and_doe_objects(objective_option):
 
     DoE_args = get_standard_args(experiment, fd_method, obj_used)
     DoE_args["use_grey_box_objective"] = True
+    DoE_args["prior_FIM"] = testing_matrix
 
     doe_obj = DesignOfExperiments(**DoE_args)
     doe_obj.create_doe_model()
@@ -585,6 +586,67 @@ def test_evaluate_hessian_equality_constraints(self):
         # should be `None` as there are no
         # equality constraints
         self.assertIsNone(hess_eq_con_vals_gb)
+    
+    # The following few tests will test whether
+    # the DoE problem with grey box is built
+    # properly.
+    def test_A_opt_greybox_build(self):
+        objective_option = "trace"
+        doe_obj, _ = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
+
+        # Build the greybox objective block
+        # on the DoE object
+        doe_obj.create_grey_box_objective_function()
+
+        # Check to see if each component exists
+        all_exist = True
+        
+        # Check output and value
+        A_opt_val = np.trace(np.linalg.inv(testing_matrix))
+
+        try:
+            A_opt_val_gb = doe_obj.model.obj_cons.egb_fim_block.outputs["A-opt"]()
+        except:
+            A_opt_val_gb = -10.0  # Trace should never be negative
+            all_exist = False
+        
+        # Intermediate check for output existence
+        self.assertTrue(all_exist)
+        # self.assertAlmostEqual(A_opt_val, A_opt_val_gb)
+
+        # Check inputs and values
+        try:
+            input_values = []
+            for i in _.input_names():
+                input_values.append(doe_obj.model.obj_cons.egb_fim_block.inputs[i]())
+        except:
+            input_values = np.zeros_like(testing_matrix)
+            all_exist = False
+        
+        # Final check on existence of inputs
+        self.assertTrue(all_exist)
+        current_FIM = np.zeros_like(testing_matrix)
+        current_FIM[np.triu_indices_from(current_FIM)] = input_values
+        print("Checkpoint before doing some math")
+        print(input_values)
+        print(current_FIM)
+        current_FIM += current_FIM.transpose() - np.diag(np.diag(current_FIM))
+        
+        print("FIM from input values")
+        print(current_FIM)
+        print("FIM from testing file")
+        print(testing_matrix + np.eye(4))
+        print("FIM from doe object")
+        print(np.asarray(doe_obj.get_FIM()))
+
+        self.assertTrue(np.all(np.isclose(current_FIM, testing_matrix + np.eye(4))))
+
+
+
+
+
 
 
 if __name__ == "__main__":

From cf75f321d402a6fefaa6aaca20975fdd2bf4b2c4 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 10:05:46 -0400
Subject: [PATCH 052/143] Found a bug while testing!

YAY!
---
 pyomo/contrib/doe/grey_box_utilities.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index ccc84121ac0..ef1a0fd67d3 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -98,6 +98,7 @@ def __init__(self, doe_object, objective_option="determinant", logger_level=None
         self._input_values = np.asarray(
             self.doe_object.fim_initial[self._masking_matrix > 0], dtype=np.float64
         )
+        print(self.doe_object.fim_initial)
         print(self.doe_object.fim_initial[self._masking_matrix > 0])
         self._n_inputs = len(self._input_values)
         # print(self._input_values)
@@ -153,6 +154,8 @@ def output_names(self):
 
     def set_input_values(self, input_values):
         # Set initial values to be flattened initial FIM (aligns with input names)
+        print("Called set input values")
+        print(input_values)
         np.copyto(self._input_values, input_values)
         # self._input_values = list(self.doe_object.fim_initial.flatten())
 
@@ -196,7 +199,7 @@ def finalize_block_construction(self, pyomo_block):
 
         # Initialize grey box FIM values
         for ind, val in enumerate(self.input_names()):
-            pyomo_block.inputs[val] = self.doe_object.fim_initial.flatten()[ind]
+            pyomo_block.inputs[val] = self.doe_object.fim_initial[self._masking_matrix > 0][ind]
 
         # Initialize log_determinant value
         from pyomo.contrib.doe import ObjectiveLib

From 7902a66859b612f6869e317290b8ebeae978f2c5 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 10:13:05 -0400
Subject: [PATCH 053/143] Fix A-opt build test.

Also removed print debugging statements I added.
---
 pyomo/contrib/doe/grey_box_utilities.py |  2 --
 pyomo/contrib/doe/tests/test_greybox.py | 21 ++++++++-------------
 2 files changed, 8 insertions(+), 15 deletions(-)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index ef1a0fd67d3..9c1c2f831d1 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -98,8 +98,6 @@ def __init__(self, doe_object, objective_option="determinant", logger_level=None
         self._input_values = np.asarray(
             self.doe_object.fim_initial[self._masking_matrix > 0], dtype=np.float64
         )
-        print(self.doe_object.fim_initial)
-        print(self.doe_object.fim_initial[self._masking_matrix > 0])
         self._n_inputs = len(self._input_values)
         # print(self._input_values)
 
diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index bc1b085d10d..fe6461198df 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -604,17 +604,20 @@ def test_A_opt_greybox_build(self):
         all_exist = True
         
         # Check output and value
-        A_opt_val = np.trace(np.linalg.inv(testing_matrix))
+        # FIM Initial will be the prior FIM
+        # added with the identity matrix.
+        A_opt_val = np.trace(np.linalg.inv(testing_matrix + np.eye(4)))
 
         try:
-            A_opt_val_gb = doe_obj.model.obj_cons.egb_fim_block.outputs["A-opt"]()
+            doe_obj.model.obj_cons.egb_fim_block.outputs.pprint()
+            A_opt_val_gb = doe_obj.model.obj_cons.egb_fim_block.outputs["A-opt"].value
         except:
             A_opt_val_gb = -10.0  # Trace should never be negative
             all_exist = False
         
         # Intermediate check for output existence
         self.assertTrue(all_exist)
-        # self.assertAlmostEqual(A_opt_val, A_opt_val_gb)
+        self.assertAlmostEqual(A_opt_val, A_opt_val_gb)
 
         # Check inputs and values
         try:
@@ -627,19 +630,11 @@ def test_A_opt_greybox_build(self):
         
         # Final check on existence of inputs
         self.assertTrue(all_exist)
+        # Rebuild the current FIM from the input
+        # values taken from the egb_fim_block
         current_FIM = np.zeros_like(testing_matrix)
         current_FIM[np.triu_indices_from(current_FIM)] = input_values
-        print("Checkpoint before doing some math")
-        print(input_values)
-        print(current_FIM)
         current_FIM += current_FIM.transpose() - np.diag(np.diag(current_FIM))
-        
-        print("FIM from input values")
-        print(current_FIM)
-        print("FIM from testing file")
-        print(testing_matrix + np.eye(4))
-        print("FIM from doe object")
-        print(np.asarray(doe_obj.get_FIM()))
 
         self.assertTrue(np.all(np.isclose(current_FIM, testing_matrix + np.eye(4))))
 

From 902f99fcd5b5fcda46be77d0d9611ab5ae15e04f Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 11:32:17 -0400
Subject: [PATCH 054/143] Added more tests

---
 pyomo/contrib/doe/tests/test_greybox.py | 139 +++++++++++++++++++++++-
 1 file changed, 138 insertions(+), 1 deletion(-)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index fe6461198df..b057975eb60 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -609,7 +609,6 @@ def test_A_opt_greybox_build(self):
         A_opt_val = np.trace(np.linalg.inv(testing_matrix + np.eye(4)))
 
         try:
-            doe_obj.model.obj_cons.egb_fim_block.outputs.pprint()
             A_opt_val_gb = doe_obj.model.obj_cons.egb_fim_block.outputs["A-opt"].value
         except:
             A_opt_val_gb = -10.0  # Trace should never be negative
@@ -637,10 +636,148 @@ def test_A_opt_greybox_build(self):
         current_FIM += current_FIM.transpose() - np.diag(np.diag(current_FIM))
 
         self.assertTrue(np.all(np.isclose(current_FIM, testing_matrix + np.eye(4))))
+    
+    def test_D_opt_greybox_build(self):
+        objective_option = "determinant"
+        doe_obj, _ = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
+
+        # Build the greybox objective block
+        # on the DoE object
+        doe_obj.create_grey_box_objective_function()
+
+        # Check to see if each component exists
+        all_exist = True
+        
+        # Check output and value
+        # FIM Initial will be the prior FIM
+        # added with the identity matrix.
+        D_opt_val = np.log(np.linalg.det(testing_matrix + np.eye(4)))
+
+        try:
+            D_opt_val_gb = doe_obj.model.obj_cons.egb_fim_block.outputs["log-D-opt"].value
+        except:
+            D_opt_val_gb = -100.0  # Determinant should never be negative beyond -64
+            all_exist = False
+        
+        # Intermediate check for output existence
+        self.assertTrue(all_exist)
+        self.assertAlmostEqual(D_opt_val, D_opt_val_gb)
+
+        # Check inputs and values
+        try:
+            input_values = []
+            for i in _.input_names():
+                input_values.append(doe_obj.model.obj_cons.egb_fim_block.inputs[i]())
+        except:
+            input_values = np.zeros_like(testing_matrix)
+            all_exist = False
+        
+        # Final check on existence of inputs
+        self.assertTrue(all_exist)
+        # Rebuild the current FIM from the input
+        # values taken from the egb_fim_block
+        current_FIM = np.zeros_like(testing_matrix)
+        current_FIM[np.triu_indices_from(current_FIM)] = input_values
+        current_FIM += current_FIM.transpose() - np.diag(np.diag(current_FIM))
+
+        self.assertTrue(np.all(np.isclose(current_FIM, testing_matrix + np.eye(4))))
+    
+    def test_E_opt_greybox_build(self):
+        objective_option = "minimum_eigenvalue"
+        doe_obj, _ = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
+
+        # Build the greybox objective block
+        # on the DoE object
+        doe_obj.create_grey_box_objective_function()
+
+        # Check to see if each component exists
+        all_exist = True
+        
+        # Check output and value
+        # FIM Initial will be the prior FIM
+        # added with the identity matrix.
+        vals, vecs = np.linalg.eig(testing_matrix + np.eye(4))
+        E_opt_val = np.min(vals)
+
+        try:
+            E_opt_val_gb = doe_obj.model.obj_cons.egb_fim_block.outputs["E-opt"].value
+        except:
+            E_opt_val_gb = -10.0  # Determinant should never be negative
+            all_exist = False
+        
+        # Intermediate check for output existence
+        self.assertTrue(all_exist)
+        self.assertAlmostEqual(E_opt_val, E_opt_val_gb)
 
+        # Check inputs and values
+        try:
+            input_values = []
+            for i in _.input_names():
+                input_values.append(doe_obj.model.obj_cons.egb_fim_block.inputs[i]())
+        except:
+            input_values = np.zeros_like(testing_matrix)
+            all_exist = False
+        
+        # Final check on existence of inputs
+        self.assertTrue(all_exist)
+        # Rebuild the current FIM from the input
+        # values taken from the egb_fim_block
+        current_FIM = np.zeros_like(testing_matrix)
+        current_FIM[np.triu_indices_from(current_FIM)] = input_values
+        current_FIM += current_FIM.transpose() - np.diag(np.diag(current_FIM))
 
+        self.assertTrue(np.all(np.isclose(current_FIM, testing_matrix + np.eye(4))))
+    
+    def test_ME_opt_greybox_build(self):
+        objective_option = "condition_number"
+        doe_obj, _ = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
 
+        # Build the greybox objective block
+        # on the DoE object
+        doe_obj.create_grey_box_objective_function()
 
+        # Check to see if each component exists
+        all_exist = True
+        
+        # Check output and value
+        # FIM Initial will be the prior FIM
+        # added with the identity matrix.
+        ME_opt_val = np.linalg.cond(testing_matrix + np.eye(4))
+
+        try:
+            ME_opt_val_gb = doe_obj.model.obj_cons.egb_fim_block.outputs["ME-opt"].value
+        except:
+            ME_opt_val_gb = -10.0  # Condition number should not be negative
+            all_exist = False
+        
+        # Intermediate check for output existence
+        self.assertTrue(all_exist)
+        self.assertAlmostEqual(ME_opt_val, ME_opt_val_gb)
+
+        # Check inputs and values
+        try:
+            input_values = []
+            for i in _.input_names():
+                input_values.append(doe_obj.model.obj_cons.egb_fim_block.inputs[i]())
+        except:
+            input_values = np.zeros_like(testing_matrix)
+            all_exist = False
+        
+        # Final check on existence of inputs
+        self.assertTrue(all_exist)
+        # Rebuild the current FIM from the input
+        # values taken from the egb_fim_block
+        current_FIM = np.zeros_like(testing_matrix)
+        current_FIM[np.triu_indices_from(current_FIM)] = input_values
+        current_FIM += current_FIM.transpose() - np.diag(np.diag(current_FIM))
+
+        self.assertTrue(np.all(np.isclose(current_FIM, testing_matrix + np.eye(4))))
 
 
 

From 917f73bd2aa703b54062a8dece243c04b01db688 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 11:32:36 -0400
Subject: [PATCH 055/143] Adding back Hessian calculation

---
 pyomo/contrib/doe/grey_box_utilities.py | 120 ++++++++++++------------
 1 file changed, 60 insertions(+), 60 deletions(-)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index 9c1c2f831d1..eba8c3e3c5d 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -360,63 +360,63 @@ def evaluate_hessian_equality_constraints(self):
         # No constraints so this returns `None`
         return None
 
-    # def evaluate_hessian_outputs(self, FIM=None):
-    #     # ToDo: significant bookkeeping if the hessian's require vectorized
-    #     # operations. Just need mapping that works well and we are good.
-    #     if FIM is None:
-    #         current_FIM = self._get_FIM()
-    #     else:
-    #         current_FIM = FIM
-    #     M = np.asarray(current_FIM, dtype=np.float64).reshape(
-    #         self._n_params, self._n_params
-    #     )
-
-    #     # Hessian with correct size for using only the
-    #     # lower (upper) triangle of the FIM
-    #     hess = np.zeros((self._n_inputs, self._n_inputs))
-
-    #     from pyomo.contrib.doe import ObjectiveLib
-    #     if self.objective_option == ObjectiveLib.determinant:
-    #         # Grab inverse
-    #         Minv = np.linalg.pinv(M)
-
-    #         # Equation derived, shown in greybox
-    #         # pyomo.DoE 2.0 paper
-    #         # dMinv/dM(i,j,k,l) = -1/2(Minv[i, k]Minv[l, j] +
-    #         #                          Minv[i, l]Minv[k, j])
-    #         lower_tri_inds_4D = itertools.combinations_with_replacement(range(self._n_params), 4)
-    #         for curr_location in lower_tri_inds_4D:
-    #             # For quadruples (i, j, k, l)...
-    #             # Row of hessian is sum from
-    #             # n - i + 1 to n minus i plus j
-    #             #
-    #             # Column of hessian is sum from
-    #             # n - k + 1 to n minus k plus l
-    #             i, j, k, l = curr_location
-    #             print(i, j, k, l)
-    #             row = sum(range(self._n_params - i + 1, self._n_params + 1)) - i + j
-    #             col = sum(range(self._n_params - k + 1, self._n_params + 1)) - k + l
-    #             #hess[row, col] = -(1/2) * (Minv[i, k] * Minv[l, j] + Minv[i, l] * Minv[j, k])
-    #             # New Formula (tested with finite differencing)
-    #             hess[row, col] = -(Minv[i, l] * Minv[k, j])
-
-    #         print(hess)
-    #         # Complete the full matrix
-    #         hess = hess.transpose()
-    #     elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
-    #         pass
-    #     elif self.objective_option == ObjectiveLib.condition_number:
-    #         pass
-
-    #     # Select only lower triangular values as a flat array
-    #     hess_masking_matrix = np.tril(np.ones_like(hess))
-    #     hess_data = hess[hess_masking_matrix > 0]
-    #     hess_rows, hess_cols  = np.tril_indices_from(hess)
-
-    #     print(hess_rows)
-    #     print(hess_cols)
-
-    #     # Returns coo_matrix of the correct shape
-    #     return coo_matrix(
-    #         (hess_data, (hess_rows, hess_cols)), shape=hess.shape
-    #     )
+    def evaluate_hessian_outputs(self, FIM=None):
+        # ToDo: significant bookkeeping if the hessian's require vectorized
+        # operations. Just need mapping that works well and we are good.
+        current_FIM = self._get_FIM()
+
+        M = np.asarray(current_FIM, dtype=np.float64).reshape(
+            self._n_params, self._n_params
+        )
+
+        # Hessian with correct size for using only the
+        # lower (upper) triangle of the FIM
+        hess = np.zeros((self._n_inputs, self._n_inputs))
+
+        from pyomo.contrib.doe import ObjectiveLib
+        if self.objective_option == ObjectiveLib.trace:
+            pass
+        elif self.objective_option == ObjectiveLib.determinant:
+            # Grab inverse
+            Minv = np.linalg.pinv(M)
+
+            # Equation derived, shown in greybox
+            # pyomo.DoE 2.0 paper
+            # dMinv/dM(i,j,k,l) = -1/2(Minv[i, k]Minv[l, j] +
+            #                          Minv[i, l]Minv[k, j])
+            lower_tri_inds_4D = itertools.combinations_with_replacement(range(self._n_params), 4)
+            for curr_location in lower_tri_inds_4D:
+                # For quadruples (i, j, k, l)...
+                # Row of hessian is sum from
+                # n - i + 1 to n minus i plus j
+                #
+                # Column of hessian is sum from
+                # n - k + 1 to n minus k plus l
+                i, j, k, l = curr_location
+                print(i, j, k, l)
+                row = sum(range(self._n_params - i + 1, self._n_params + 1)) - i + j
+                col = sum(range(self._n_params - k + 1, self._n_params + 1)) - k + l
+                #hess[row, col] = -(1/2) * (Minv[i, k] * Minv[l, j] + Minv[i, l] * Minv[j, k])
+                # New Formula (tested with finite differencing)
+                hess[row, col] = -(Minv[i, l] * Minv[k, j])
+
+            print(hess)
+            # Complete the full matrix
+            hess = hess.transpose()
+        elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
+            pass
+        elif self.objective_option == ObjectiveLib.condition_number:
+            pass
+
+        # Select only lower triangular values as a flat array
+        hess_masking_matrix = np.tril(np.ones_like(hess))
+        hess_data = hess[hess_masking_matrix > 0]
+        hess_rows, hess_cols  = np.tril_indices_from(hess)
+
+        print(hess_rows)
+        print(hess_cols)
+
+        # Returns coo_matrix of the correct shape
+        return coo_matrix(
+            (hess_data, (hess_rows, hess_cols)), shape=hess.shape
+        )

From 9c9cc9fbce25017ad54143cca358330c5f7d58e4 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 11:32:57 -0400
Subject: [PATCH 056/143] Ran black

---
 pyomo/contrib/doe/grey_box_utilities.py | 17 ++++----
 pyomo/contrib/doe/tests/test_greybox.py | 53 +++++++++++--------------
 2 files changed, 33 insertions(+), 37 deletions(-)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index eba8c3e3c5d..d5523bb2e61 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -197,7 +197,9 @@ def finalize_block_construction(self, pyomo_block):
 
         # Initialize grey box FIM values
         for ind, val in enumerate(self.input_names()):
-            pyomo_block.inputs[val] = self.doe_object.fim_initial[self._masking_matrix > 0][ind]
+            pyomo_block.inputs[val] = self.doe_object.fim_initial[
+                self._masking_matrix > 0
+            ][ind]
 
         # Initialize log_determinant value
         from pyomo.contrib.doe import ObjectiveLib
@@ -374,6 +376,7 @@ def evaluate_hessian_outputs(self, FIM=None):
         hess = np.zeros((self._n_inputs, self._n_inputs))
 
         from pyomo.contrib.doe import ObjectiveLib
+
         if self.objective_option == ObjectiveLib.trace:
             pass
         elif self.objective_option == ObjectiveLib.determinant:
@@ -384,7 +387,9 @@ def evaluate_hessian_outputs(self, FIM=None):
             # pyomo.DoE 2.0 paper
             # dMinv/dM(i,j,k,l) = -1/2(Minv[i, k]Minv[l, j] +
             #                          Minv[i, l]Minv[k, j])
-            lower_tri_inds_4D = itertools.combinations_with_replacement(range(self._n_params), 4)
+            lower_tri_inds_4D = itertools.combinations_with_replacement(
+                range(self._n_params), 4
+            )
             for curr_location in lower_tri_inds_4D:
                 # For quadruples (i, j, k, l)...
                 # Row of hessian is sum from
@@ -396,7 +401,7 @@ def evaluate_hessian_outputs(self, FIM=None):
                 print(i, j, k, l)
                 row = sum(range(self._n_params - i + 1, self._n_params + 1)) - i + j
                 col = sum(range(self._n_params - k + 1, self._n_params + 1)) - k + l
-                #hess[row, col] = -(1/2) * (Minv[i, k] * Minv[l, j] + Minv[i, l] * Minv[j, k])
+                # hess[row, col] = -(1/2) * (Minv[i, k] * Minv[l, j] + Minv[i, l] * Minv[j, k])
                 # New Formula (tested with finite differencing)
                 hess[row, col] = -(Minv[i, l] * Minv[k, j])
 
@@ -411,12 +416,10 @@ def evaluate_hessian_outputs(self, FIM=None):
         # Select only lower triangular values as a flat array
         hess_masking_matrix = np.tril(np.ones_like(hess))
         hess_data = hess[hess_masking_matrix > 0]
-        hess_rows, hess_cols  = np.tril_indices_from(hess)
+        hess_rows, hess_cols = np.tril_indices_from(hess)
 
         print(hess_rows)
         print(hess_cols)
 
         # Returns coo_matrix of the correct shape
-        return coo_matrix(
-            (hess_data, (hess_rows, hess_cols)), shape=hess.shape
-        )
+        return coo_matrix((hess_data, (hess_rows, hess_cols)), shape=hess.shape)
diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index b057975eb60..8e242fa1b2b 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -586,15 +586,13 @@ def test_evaluate_hessian_equality_constraints(self):
         # should be `None` as there are no
         # equality constraints
         self.assertIsNone(hess_eq_con_vals_gb)
-    
+
     # The following few tests will test whether
     # the DoE problem with grey box is built
     # properly.
     def test_A_opt_greybox_build(self):
         objective_option = "trace"
-        doe_obj, _ = make_greybox_and_doe_objects(
-            objective_option=objective_option
-        )
+        doe_obj, _ = make_greybox_and_doe_objects(objective_option=objective_option)
 
         # Build the greybox objective block
         # on the DoE object
@@ -602,7 +600,7 @@ def test_A_opt_greybox_build(self):
 
         # Check to see if each component exists
         all_exist = True
-        
+
         # Check output and value
         # FIM Initial will be the prior FIM
         # added with the identity matrix.
@@ -613,7 +611,7 @@ def test_A_opt_greybox_build(self):
         except:
             A_opt_val_gb = -10.0  # Trace should never be negative
             all_exist = False
-        
+
         # Intermediate check for output existence
         self.assertTrue(all_exist)
         self.assertAlmostEqual(A_opt_val, A_opt_val_gb)
@@ -626,7 +624,7 @@ def test_A_opt_greybox_build(self):
         except:
             input_values = np.zeros_like(testing_matrix)
             all_exist = False
-        
+
         # Final check on existence of inputs
         self.assertTrue(all_exist)
         # Rebuild the current FIM from the input
@@ -636,12 +634,10 @@ def test_A_opt_greybox_build(self):
         current_FIM += current_FIM.transpose() - np.diag(np.diag(current_FIM))
 
         self.assertTrue(np.all(np.isclose(current_FIM, testing_matrix + np.eye(4))))
-    
+
     def test_D_opt_greybox_build(self):
         objective_option = "determinant"
-        doe_obj, _ = make_greybox_and_doe_objects(
-            objective_option=objective_option
-        )
+        doe_obj, _ = make_greybox_and_doe_objects(objective_option=objective_option)
 
         # Build the greybox objective block
         # on the DoE object
@@ -649,18 +645,20 @@ def test_D_opt_greybox_build(self):
 
         # Check to see if each component exists
         all_exist = True
-        
+
         # Check output and value
         # FIM Initial will be the prior FIM
         # added with the identity matrix.
         D_opt_val = np.log(np.linalg.det(testing_matrix + np.eye(4)))
 
         try:
-            D_opt_val_gb = doe_obj.model.obj_cons.egb_fim_block.outputs["log-D-opt"].value
+            D_opt_val_gb = doe_obj.model.obj_cons.egb_fim_block.outputs[
+                "log-D-opt"
+            ].value
         except:
             D_opt_val_gb = -100.0  # Determinant should never be negative beyond -64
             all_exist = False
-        
+
         # Intermediate check for output existence
         self.assertTrue(all_exist)
         self.assertAlmostEqual(D_opt_val, D_opt_val_gb)
@@ -673,7 +671,7 @@ def test_D_opt_greybox_build(self):
         except:
             input_values = np.zeros_like(testing_matrix)
             all_exist = False
-        
+
         # Final check on existence of inputs
         self.assertTrue(all_exist)
         # Rebuild the current FIM from the input
@@ -683,12 +681,10 @@ def test_D_opt_greybox_build(self):
         current_FIM += current_FIM.transpose() - np.diag(np.diag(current_FIM))
 
         self.assertTrue(np.all(np.isclose(current_FIM, testing_matrix + np.eye(4))))
-    
+
     def test_E_opt_greybox_build(self):
         objective_option = "minimum_eigenvalue"
-        doe_obj, _ = make_greybox_and_doe_objects(
-            objective_option=objective_option
-        )
+        doe_obj, _ = make_greybox_and_doe_objects(objective_option=objective_option)
 
         # Build the greybox objective block
         # on the DoE object
@@ -696,7 +692,7 @@ def test_E_opt_greybox_build(self):
 
         # Check to see if each component exists
         all_exist = True
-        
+
         # Check output and value
         # FIM Initial will be the prior FIM
         # added with the identity matrix.
@@ -708,7 +704,7 @@ def test_E_opt_greybox_build(self):
         except:
             E_opt_val_gb = -10.0  # Determinant should never be negative
             all_exist = False
-        
+
         # Intermediate check for output existence
         self.assertTrue(all_exist)
         self.assertAlmostEqual(E_opt_val, E_opt_val_gb)
@@ -721,7 +717,7 @@ def test_E_opt_greybox_build(self):
         except:
             input_values = np.zeros_like(testing_matrix)
             all_exist = False
-        
+
         # Final check on existence of inputs
         self.assertTrue(all_exist)
         # Rebuild the current FIM from the input
@@ -731,12 +727,10 @@ def test_E_opt_greybox_build(self):
         current_FIM += current_FIM.transpose() - np.diag(np.diag(current_FIM))
 
         self.assertTrue(np.all(np.isclose(current_FIM, testing_matrix + np.eye(4))))
-    
+
     def test_ME_opt_greybox_build(self):
         objective_option = "condition_number"
-        doe_obj, _ = make_greybox_and_doe_objects(
-            objective_option=objective_option
-        )
+        doe_obj, _ = make_greybox_and_doe_objects(objective_option=objective_option)
 
         # Build the greybox objective block
         # on the DoE object
@@ -744,7 +738,7 @@ def test_ME_opt_greybox_build(self):
 
         # Check to see if each component exists
         all_exist = True
-        
+
         # Check output and value
         # FIM Initial will be the prior FIM
         # added with the identity matrix.
@@ -755,7 +749,7 @@ def test_ME_opt_greybox_build(self):
         except:
             ME_opt_val_gb = -10.0  # Condition number should not be negative
             all_exist = False
-        
+
         # Intermediate check for output existence
         self.assertTrue(all_exist)
         self.assertAlmostEqual(ME_opt_val, ME_opt_val_gb)
@@ -768,7 +762,7 @@ def test_ME_opt_greybox_build(self):
         except:
             input_values = np.zeros_like(testing_matrix)
             all_exist = False
-        
+
         # Final check on existence of inputs
         self.assertTrue(all_exist)
         # Rebuild the current FIM from the input
@@ -780,6 +774,5 @@ def test_ME_opt_greybox_build(self):
         self.assertTrue(np.all(np.isclose(current_FIM, testing_matrix + np.eye(4))))
 
 
-
 if __name__ == "__main__":
     unittest.main()

From e58e0f81c322d6041dea9ef05fc9ba35a431c52a Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 12:00:50 -0400
Subject: [PATCH 057/143] Updated hessian computation for log-det

---
 pyomo/contrib/doe/grey_box_utilities.py | 46 ++++++++++++++-----------
 1 file changed, 25 insertions(+), 21 deletions(-)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index d5523bb2e61..23622adbe1c 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -383,31 +383,35 @@ def evaluate_hessian_outputs(self, FIM=None):
             # Grab inverse
             Minv = np.linalg.pinv(M)
 
-            # Equation derived, shown in greybox
-            # pyomo.DoE 2.0 paper
-            # dMinv/dM(i,j,k,l) = -1/2(Minv[i, k]Minv[l, j] +
-            #                          Minv[i, l]Minv[k, j])
-            lower_tri_inds_4D = itertools.combinations_with_replacement(
-                range(self._n_params), 4
+            input_differentials_2D = itertools.combinations_with_replacement(
+                self.input_names(), 2
             )
-            for curr_location in lower_tri_inds_4D:
-                # For quadruples (i, j, k, l)...
-                # Row of hessian is sum from
-                # n - i + 1 to n minus i plus j
+            for current_differential in input_differentials_2D:
+                # Row will be the location of the
+                # first ordered pair (d1) in input names
                 #
-                # Column of hessian is sum from
-                # n - k + 1 to n minus k plus l
-                i, j, k, l = curr_location
-                print(i, j, k, l)
-                row = sum(range(self._n_params - i + 1, self._n_params + 1)) - i + j
-                col = sum(range(self._n_params - k + 1, self._n_params + 1)) - k + l
-                # hess[row, col] = -(1/2) * (Minv[i, k] * Minv[l, j] + Minv[i, l] * Minv[j, k])
+                # Col will be the location of the
+                # second ordered pair (d2) in input names
+                d1, d2 = current_differential
+                row = self.input_names().index(d1)
+                col = self.input_names().index(d2)
+
+                # Grabbing the ordered quadruple (i, j, k, l)
+                # `location` here refers to the index in the
+                # self._param_names list
+                #
+                # i is the location of the first element of d1
+                # j is the location of the second element of d1
+                # k is the location of the first element of d2
+                # l is the location of the second element of d2
+                i = self._param_names.index(d1[0])
+                j = self._param_names.index(d1[1])
+                k = self._param_names.index(d2[0])
+                l = self._param_names.index(d2[2])
+
                 # New Formula (tested with finite differencing)
+                # Will be cited from the Pyomo.DoE 2.0 paper
                 hess[row, col] = -(Minv[i, l] * Minv[k, j])
-
-            print(hess)
-            # Complete the full matrix
-            hess = hess.transpose()
         elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
             pass
         elif self.objective_option == ObjectiveLib.condition_number:

From d8cfda1665c7bfc254a9b1c3cd007b1ec10eeed9 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 13:15:19 -0400
Subject: [PATCH 058/143] Added D-opt hessian test!

---
 pyomo/contrib/doe/grey_box_utilities.py | 60 ++++++++++++-------
 pyomo/contrib/doe/tests/test_greybox.py | 76 ++++++++++++++++++++-----
 2 files changed, 104 insertions(+), 32 deletions(-)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index 23622adbe1c..15fd7bfa154 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -152,8 +152,6 @@ def output_names(self):
 
     def set_input_values(self, input_values):
         # Set initial values to be flattened initial FIM (aligns with input names)
-        print("Called set input values")
-        print(input_values)
         np.copyto(self._input_values, input_values)
         # self._input_values = list(self.doe_object.fim_initial.flatten())
 
@@ -373,19 +371,25 @@ def evaluate_hessian_outputs(self, FIM=None):
 
         # Hessian with correct size for using only the
         # lower (upper) triangle of the FIM
-        hess = np.zeros((self._n_inputs, self._n_inputs))
+        hess_vals = []
+        hess_rows = []
+        hess_cols = []
+
+        # Need to iterate over the unique 
+        # differentials
+        input_differentials_2D = itertools.combinations_with_replacement(
+                self.input_names(), 2
+            )
 
         from pyomo.contrib.doe import ObjectiveLib
 
         if self.objective_option == ObjectiveLib.trace:
-            pass
-        elif self.objective_option == ObjectiveLib.determinant:
-            # Grab inverse
+            # Grab Inverse
             Minv = np.linalg.pinv(M)
+            
+            # Also grab inverse squared
+            Minv_sq = Minv @ Minv
 
-            input_differentials_2D = itertools.combinations_with_replacement(
-                self.input_names(), 2
-            )
             for current_differential in input_differentials_2D:
                 # Row will be the location of the
                 # first ordered pair (d1) in input names
@@ -407,23 +411,41 @@ def evaluate_hessian_outputs(self, FIM=None):
                 i = self._param_names.index(d1[0])
                 j = self._param_names.index(d1[1])
                 k = self._param_names.index(d2[0])
-                l = self._param_names.index(d2[2])
+                l = self._param_names.index(d2[1])
 
                 # New Formula (tested with finite differencing)
                 # Will be cited from the Pyomo.DoE 2.0 paper
-                hess[row, col] = -(Minv[i, l] * Minv[k, j])
+                hess_vals.append((Minv[i, l] * Minv_sq[k, j]) + (Minv_sq[i, l] * Minv[k, j]))
+                hess_rows.append(row)
+                hess_cols.append(col)
+
+        elif self.objective_option == ObjectiveLib.determinant:
+            # Grab inverse
+            Minv = np.linalg.pinv(M)
+
+            for current_differential in input_differentials_2D:
+                # Row, Col and i, j, k, l values are
+                # obtained identically as in the trace
+                # for loop above.
+                d1, d2 = current_differential
+                row = self.input_names().index(d1)
+                col = self.input_names().index(d2)
+
+                i = self._param_names.index(d1[0])
+                j = self._param_names.index(d1[1])
+                k = self._param_names.index(d2[0])
+                l = self._param_names.index(d2[1])
+
+                # New Formula (tested with finite differencing)
+                # Will be cited from the Pyomo.DoE 2.0 paper
+                hess_vals.append(-(Minv[i, l] * Minv[k, j]))
+                hess_rows.append(row)
+                hess_cols.append(col)
         elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
             pass
         elif self.objective_option == ObjectiveLib.condition_number:
             pass
 
-        # Select only lower triangular values as a flat array
-        hess_masking_matrix = np.tril(np.ones_like(hess))
-        hess_data = hess[hess_masking_matrix > 0]
-        hess_rows, hess_cols = np.tril_indices_from(hess)
-
-        print(hess_rows)
-        print(hess_cols)
 
         # Returns coo_matrix of the correct shape
-        return coo_matrix((hess_data, (hess_rows, hess_cols)), shape=hess.shape)
+        return coo_matrix((np.asarray(hess_vals), (hess_rows, hess_cols)), shape=(self._n_inputs, self._n_inputs))
diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 8e242fa1b2b..8e30680b224 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -9,6 +9,7 @@
 #  This software is distributed under the 3-clause BSD License.
 #  ___________________________________________________________________________
 import copy
+import itertools
 import json
 import os.path
 
@@ -40,7 +41,8 @@
 
 data_ex["control_points"] = {float(k): v for k, v in data_ex["control_points"].items()}
 
-_FD_EPSILON = 1e-6  # Epsilon for numerical comparison of derivatives
+_FD_EPSILON_FIRST = 1e-6  # Epsilon for numerical comparison of derivatives
+_FD_EPSILON_SECOND = 1e-4  # Epsilon for numerical comparison of derivatives
 
 if numpy_available:
     # Randomly generated P.S.D. matrix
@@ -85,7 +87,7 @@ def get_numerical_derivative(grey_box_object=None):
     for i in range(dim):
         for j in range(dim):
             FIM_perturbed = copy.deepcopy(current_FIM)
-            FIM_perturbed[i, j] += _FD_EPSILON
+            FIM_perturbed[i, j] += _FD_EPSILON_FIRST
 
             new_value_ij = 0
             # Test which method is being used:
@@ -100,14 +102,14 @@ def get_numerical_derivative(grey_box_object=None):
                 new_value_ij = np.linalg.cond(FIM_perturbed)
 
             # Calculate the derivative value from forward difference
-            diff = (new_value_ij - unperturbed_value) / _FD_EPSILON
+            diff = (new_value_ij - unperturbed_value) / _FD_EPSILON_FIRST
 
             numerical_derivative[i, j] = diff
 
     return numerical_derivative
 
 
-def get_numerical_second_derivative(grey_box_object=None):
+def get_numerical_second_derivative(grey_box_object=None, return_reduced=True):
     # Internal import to avoid circular imports
     from pyomo.contrib.doe import ObjectiveLib
 
@@ -134,17 +136,17 @@ def get_numerical_second_derivative(grey_box_object=None):
                     # + (FIM +/- eps one each)
                     # + (FIM -/+ eps one each)
                     # + (FIM - eps (both))] / (4*eps**2)
-                    FIM_perturbed_1[i, j] += _FD_EPSILON
-                    FIM_perturbed_1[k, l] += _FD_EPSILON
+                    FIM_perturbed_1[i, j] += _FD_EPSILON_SECOND
+                    FIM_perturbed_1[k, l] += _FD_EPSILON_SECOND
 
-                    FIM_perturbed_2[i, j] += _FD_EPSILON
-                    FIM_perturbed_2[k, l] += -_FD_EPSILON
+                    FIM_perturbed_2[i, j] += _FD_EPSILON_SECOND
+                    FIM_perturbed_2[k, l] += -_FD_EPSILON_SECOND
 
-                    FIM_perturbed_3[i, j] += -_FD_EPSILON
-                    FIM_perturbed_3[k, l] += _FD_EPSILON
+                    FIM_perturbed_3[i, j] += -_FD_EPSILON_SECOND
+                    FIM_perturbed_3[k, l] += _FD_EPSILON_SECOND
 
-                    FIM_perturbed_4[i, j] += -_FD_EPSILON
-                    FIM_perturbed_4[k, l] += -_FD_EPSILON
+                    FIM_perturbed_4[i, j] += -_FD_EPSILON_SECOND
+                    FIM_perturbed_4[k, l] += -_FD_EPSILON_SECOND
 
                     new_values = np.array([0.0, 0.0, 0.0, 0.0])
                     # Test which method is being used:
@@ -182,10 +184,33 @@ def get_numerical_second_derivative(grey_box_object=None):
                     # Calculate the derivative value from second order difference formula
                     diff = (
                         new_values[0] - new_values[1] - new_values[2] + new_values[3]
-                    ) / (4 * _FD_EPSILON**2)
+                    ) / (4 * _FD_EPSILON_SECOND**2)
 
                     numerical_derivative[i, j, k, l] = diff
 
+    if return_reduced:
+        # This considers a 4-parameter system
+        # which is what these tests are based
+        # upon. This can be generalized but
+        # requires checking the parameter length.
+        #
+        # Make ordered quads with no repeats
+        # of the ordered pairs
+        ordered_pairs = itertools.combinations_with_replacement(range(4), 2)
+        ordered_pairs_list = list(itertools.combinations_with_replacement(range(4), 2))
+        ordered_quads = itertools.combinations_with_replacement(ordered_pairs, 2)
+
+        numerical_derivative_reduced = np.zeros((10, 10))
+
+        for i in ordered_quads:
+            row = ordered_pairs_list.index(i[0])
+            col = ordered_pairs_list.index(i[1])
+            numerical_derivative_reduced[row, col] = numerical_derivative[i[0][0], i[0][1], i[1][0], i[1][1]]
+        
+        numerical_derivative_reduced += numerical_derivative_reduced.transpose() - np.diag(np.diag(numerical_derivative_reduced))
+        return numerical_derivative_reduced
+    
+    # Otherwise return numerical derivative as normal
     return numerical_derivative
 
 
@@ -533,6 +558,31 @@ def test_jacobian_ME_opt(self):
         # assert that each component is close
         self.assertTrue(np.all(np.isclose(jac, jac_FD)))
 
+    # Testing Hessian Computation
+    def test_hessian_D_opt(self):
+        objective_option = "determinant"
+        doe_obj, grey_box_object = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
+
+        # Set input values to the random testing matrix
+        grey_box_object.set_input_values(testing_matrix[masking_matrix > 0])
+
+        # Grab the Jacobian values
+        hess_vals_from_gb = grey_box_object.evaluate_hessian_outputs().toarray()
+
+        # Recover the Jacobian in Matrix Form
+        hess_gb = hess_vals_from_gb
+        hess_gb += hess_gb.transpose() - np.diag(np.diag(hess_gb))
+
+        # Get numerical derivative matrix
+        hess_FD = get_numerical_second_derivative(grey_box_object)
+
+        print(np.abs((hess_gb - hess_FD) / hess_gb))
+
+        # assert that each component is close
+        self.assertTrue(np.all(np.isclose(hess_gb, hess_FD)))
+
     def test_equality_constraint_names(self):
         objective_option = "condition_number"
         doe_obj, grey_box_object = make_greybox_and_doe_objects(

From 3dfbd0020d64baa83f803d3d3f5a29fafe1481d6 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 13:16:42 -0400
Subject: [PATCH 059/143] Adding A-opt hessian test!

---
 pyomo/contrib/doe/tests/test_greybox.py | 24 ++++++++++++++++++++++--
 1 file changed, 22 insertions(+), 2 deletions(-)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 8e30680b224..1201e9c4ec2 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -559,6 +559,28 @@ def test_jacobian_ME_opt(self):
         self.assertTrue(np.all(np.isclose(jac, jac_FD)))
 
     # Testing Hessian Computation
+    def test_hessian_A_opt(self):
+        objective_option = "trace"
+        doe_obj, grey_box_object = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
+
+        # Set input values to the random testing matrix
+        grey_box_object.set_input_values(testing_matrix[masking_matrix > 0])
+
+        # Grab the Jacobian values
+        hess_vals_from_gb = grey_box_object.evaluate_hessian_outputs().toarray()
+
+        # Recover the Jacobian in Matrix Form
+        hess_gb = hess_vals_from_gb
+        hess_gb += hess_gb.transpose() - np.diag(np.diag(hess_gb))
+
+        # Get numerical derivative matrix
+        hess_FD = get_numerical_second_derivative(grey_box_object)
+
+        # assert that each component is close
+        self.assertTrue(np.all(np.isclose(hess_gb, hess_FD)))
+    
     def test_hessian_D_opt(self):
         objective_option = "determinant"
         doe_obj, grey_box_object = make_greybox_and_doe_objects(
@@ -578,8 +600,6 @@ def test_hessian_D_opt(self):
         # Get numerical derivative matrix
         hess_FD = get_numerical_second_derivative(grey_box_object)
 
-        print(np.abs((hess_gb - hess_FD) / hess_gb))
-
         # assert that each component is close
         self.assertTrue(np.all(np.isclose(hess_gb, hess_FD)))
 

From 7dbf0df2a82bc48e536dbcb42ddd47b48b975006 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 13:16:59 -0400
Subject: [PATCH 060/143] Ran black

---
 pyomo/contrib/doe/grey_box_utilities.py | 18 +++++++++++-------
 pyomo/contrib/doe/tests/test_greybox.py | 15 ++++++++++-----
 2 files changed, 21 insertions(+), 12 deletions(-)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index 15fd7bfa154..f801d9cd90a 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -375,18 +375,18 @@ def evaluate_hessian_outputs(self, FIM=None):
         hess_rows = []
         hess_cols = []
 
-        # Need to iterate over the unique 
+        # Need to iterate over the unique
         # differentials
         input_differentials_2D = itertools.combinations_with_replacement(
-                self.input_names(), 2
-            )
+            self.input_names(), 2
+        )
 
         from pyomo.contrib.doe import ObjectiveLib
 
         if self.objective_option == ObjectiveLib.trace:
             # Grab Inverse
             Minv = np.linalg.pinv(M)
-            
+
             # Also grab inverse squared
             Minv_sq = Minv @ Minv
 
@@ -415,7 +415,9 @@ def evaluate_hessian_outputs(self, FIM=None):
 
                 # New Formula (tested with finite differencing)
                 # Will be cited from the Pyomo.DoE 2.0 paper
-                hess_vals.append((Minv[i, l] * Minv_sq[k, j]) + (Minv_sq[i, l] * Minv[k, j]))
+                hess_vals.append(
+                    (Minv[i, l] * Minv_sq[k, j]) + (Minv_sq[i, l] * Minv[k, j])
+                )
                 hess_rows.append(row)
                 hess_cols.append(col)
 
@@ -446,6 +448,8 @@ def evaluate_hessian_outputs(self, FIM=None):
         elif self.objective_option == ObjectiveLib.condition_number:
             pass
 
-
         # Returns coo_matrix of the correct shape
-        return coo_matrix((np.asarray(hess_vals), (hess_rows, hess_cols)), shape=(self._n_inputs, self._n_inputs))
+        return coo_matrix(
+            (np.asarray(hess_vals), (hess_rows, hess_cols)),
+            shape=(self._n_inputs, self._n_inputs),
+        )
diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 1201e9c4ec2..735d54ff6e0 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -205,11 +205,16 @@ def get_numerical_second_derivative(grey_box_object=None, return_reduced=True):
         for i in ordered_quads:
             row = ordered_pairs_list.index(i[0])
             col = ordered_pairs_list.index(i[1])
-            numerical_derivative_reduced[row, col] = numerical_derivative[i[0][0], i[0][1], i[1][0], i[1][1]]
-        
-        numerical_derivative_reduced += numerical_derivative_reduced.transpose() - np.diag(np.diag(numerical_derivative_reduced))
+            numerical_derivative_reduced[row, col] = numerical_derivative[
+                i[0][0], i[0][1], i[1][0], i[1][1]
+            ]
+
+        numerical_derivative_reduced += (
+            numerical_derivative_reduced.transpose()
+            - np.diag(np.diag(numerical_derivative_reduced))
+        )
         return numerical_derivative_reduced
-    
+
     # Otherwise return numerical derivative as normal
     return numerical_derivative
 
@@ -580,7 +585,7 @@ def test_hessian_A_opt(self):
 
         # assert that each component is close
         self.assertTrue(np.all(np.isclose(hess_gb, hess_FD)))
-    
+
     def test_hessian_D_opt(self):
         objective_option = "determinant"
         doe_obj, grey_box_object = make_greybox_and_doe_objects(

From 55bed44bf818564b26980b643acc2868a34d2dbd Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 13:33:27 -0400
Subject: [PATCH 061/143] Adding E-opt hessian and test

---
 pyomo/contrib/doe/grey_box_utilities.py | 46 ++++++++++++++++++++++++-
 pyomo/contrib/doe/tests/test_greybox.py | 23 +++++++++++++
 2 files changed, 68 insertions(+), 1 deletion(-)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index f801d9cd90a..b9526cd3073 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -444,7 +444,51 @@ def evaluate_hessian_outputs(self, FIM=None):
                 hess_rows.append(row)
                 hess_cols.append(col)
         elif self.objective_option == ObjectiveLib.minimum_eigenvalue:
-            pass
+            # Grab eigenvalues and eigenvectors
+            # Also need the min location
+            all_eig_vals, all_eig_vecs = np.linalg.eig(M)
+            min_eig_loc = np.argmin(all_eig_vals)
+            
+            # Grabbing min eigenvalue and corresponding
+            # eigenvector
+            min_eig = all_eig_vals[min_eig_loc]
+            min_eig_vec = np.array([all_eig_vecs[:, min_eig_loc]])
+
+            for current_differential in input_differentials_2D:
+                # Row, Col and i, j, k, l values are
+                # obtained identically as in the trace
+                # for loop above.
+                d1, d2 = current_differential
+                row = self.input_names().index(d1)
+                col = self.input_names().index(d2)
+
+                i = self._param_names.index(d1[0])
+                j = self._param_names.index(d1[1])
+                k = self._param_names.index(d2[0])
+                l = self._param_names.index(d2[1])
+
+                # For lop to iterate over all 
+                # eigenvalues/vectors
+                hess_val = 0
+                for curr_eig in range(len(all_eig_vals)):
+                    # Skip if we are at the minimum
+                    # eigenvalue. Denominator is
+                    # zero.
+                    if curr_eig == min_eig_loc:
+                        continue
+
+                    # Formula derived in Pyomo.DoE Paper
+                    hess_val += 1 * (min_eig_vec[0, i] * 
+                                      all_eig_vecs[j, curr_eig] * 
+                                      min_eig_vec[0, l] * 
+                                      all_eig_vecs[k, curr_eig]) / (min_eig - all_eig_vals[curr_eig])
+                    hess_val += 1 * (min_eig_vec[0, k] * 
+                                      all_eig_vecs[i, curr_eig] * 
+                                      min_eig_vec[0, j] * 
+                                      all_eig_vecs[l, curr_eig]) / (min_eig - all_eig_vals[curr_eig])
+                hess_vals.append(-(Minv[i, l] * Minv[k, j]))
+                hess_rows.append(row)
+                hess_cols.append(col)
         elif self.objective_option == ObjectiveLib.condition_number:
             pass
 
diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 735d54ff6e0..0b2727422cf 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -607,6 +607,29 @@ def test_hessian_D_opt(self):
 
         # assert that each component is close
         self.assertTrue(np.all(np.isclose(hess_gb, hess_FD)))
+    
+
+    def test_hessian_E_opt(self):
+        objective_option = "minimum_eigenvalue"
+        doe_obj, grey_box_object = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
+
+        # Set input values to the random testing matrix
+        grey_box_object.set_input_values(testing_matrix[masking_matrix > 0])
+
+        # Grab the Jacobian values
+        hess_vals_from_gb = grey_box_object.evaluate_hessian_outputs().toarray()
+
+        # Recover the Jacobian in Matrix Form
+        hess_gb = hess_vals_from_gb
+        hess_gb += hess_gb.transpose() - np.diag(np.diag(hess_gb))
+
+        # Get numerical derivative matrix
+        hess_FD = get_numerical_second_derivative(grey_box_object)
+
+        # assert that each component is close
+        self.assertTrue(np.all(np.isclose(hess_gb, hess_FD)))
 
     def test_equality_constraint_names(self):
         objective_option = "condition_number"

From 9bc8c815edcc1e69171ef77778e945869ad933d4 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 13:35:11 -0400
Subject: [PATCH 062/143] Fixed a typo in hessian calculation

---
 pyomo/contrib/doe/grey_box_utilities.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index b9526cd3073..cf9559c6000 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -469,7 +469,7 @@ def evaluate_hessian_outputs(self, FIM=None):
 
                 # For lop to iterate over all 
                 # eigenvalues/vectors
-                hess_val = 0
+                curr_hess_val = 0
                 for curr_eig in range(len(all_eig_vals)):
                     # Skip if we are at the minimum
                     # eigenvalue. Denominator is
@@ -478,15 +478,15 @@ def evaluate_hessian_outputs(self, FIM=None):
                         continue
 
                     # Formula derived in Pyomo.DoE Paper
-                    hess_val += 1 * (min_eig_vec[0, i] * 
+                    curr_hess_val += 1 * (min_eig_vec[0, i] * 
                                       all_eig_vecs[j, curr_eig] * 
                                       min_eig_vec[0, l] * 
                                       all_eig_vecs[k, curr_eig]) / (min_eig - all_eig_vals[curr_eig])
-                    hess_val += 1 * (min_eig_vec[0, k] * 
+                    curr_hess_val += 1 * (min_eig_vec[0, k] * 
                                       all_eig_vecs[i, curr_eig] * 
                                       min_eig_vec[0, j] * 
                                       all_eig_vecs[l, curr_eig]) / (min_eig - all_eig_vals[curr_eig])
-                hess_vals.append(-(Minv[i, l] * Minv[k, j]))
+                hess_vals.append(curr_hess_val)
                 hess_rows.append(row)
                 hess_cols.append(col)
         elif self.objective_option == ObjectiveLib.condition_number:

From cb983ff513854e3d1c964d98ce0f8fc83c727e54 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 13:35:29 -0400
Subject: [PATCH 063/143] Ran black

---
 pyomo/contrib/doe/grey_box_utilities.py | 32 +++++++++++++++++--------
 pyomo/contrib/doe/tests/test_greybox.py |  1 -
 2 files changed, 22 insertions(+), 11 deletions(-)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index cf9559c6000..e2d8e2794e9 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -448,7 +448,7 @@ def evaluate_hessian_outputs(self, FIM=None):
             # Also need the min location
             all_eig_vals, all_eig_vecs = np.linalg.eig(M)
             min_eig_loc = np.argmin(all_eig_vals)
-            
+
             # Grabbing min eigenvalue and corresponding
             # eigenvector
             min_eig = all_eig_vals[min_eig_loc]
@@ -467,7 +467,7 @@ def evaluate_hessian_outputs(self, FIM=None):
                 k = self._param_names.index(d2[0])
                 l = self._param_names.index(d2[1])
 
-                # For lop to iterate over all 
+                # For lop to iterate over all
                 # eigenvalues/vectors
                 curr_hess_val = 0
                 for curr_eig in range(len(all_eig_vals)):
@@ -478,14 +478,26 @@ def evaluate_hessian_outputs(self, FIM=None):
                         continue
 
                     # Formula derived in Pyomo.DoE Paper
-                    curr_hess_val += 1 * (min_eig_vec[0, i] * 
-                                      all_eig_vecs[j, curr_eig] * 
-                                      min_eig_vec[0, l] * 
-                                      all_eig_vecs[k, curr_eig]) / (min_eig - all_eig_vals[curr_eig])
-                    curr_hess_val += 1 * (min_eig_vec[0, k] * 
-                                      all_eig_vecs[i, curr_eig] * 
-                                      min_eig_vec[0, j] * 
-                                      all_eig_vecs[l, curr_eig]) / (min_eig - all_eig_vals[curr_eig])
+                    curr_hess_val += (
+                        1
+                        * (
+                            min_eig_vec[0, i]
+                            * all_eig_vecs[j, curr_eig]
+                            * min_eig_vec[0, l]
+                            * all_eig_vecs[k, curr_eig]
+                        )
+                        / (min_eig - all_eig_vals[curr_eig])
+                    )
+                    curr_hess_val += (
+                        1
+                        * (
+                            min_eig_vec[0, k]
+                            * all_eig_vecs[i, curr_eig]
+                            * min_eig_vec[0, j]
+                            * all_eig_vecs[l, curr_eig]
+                        )
+                        / (min_eig - all_eig_vals[curr_eig])
+                    )
                 hess_vals.append(curr_hess_val)
                 hess_rows.append(row)
                 hess_cols.append(col)
diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 0b2727422cf..a8dacdb52fb 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -607,7 +607,6 @@ def test_hessian_D_opt(self):
 
         # assert that each component is close
         self.assertTrue(np.all(np.isclose(hess_gb, hess_FD)))
-    
 
     def test_hessian_E_opt(self):
         objective_option = "minimum_eigenvalue"

From e9aed55e8225a01e2c967864152876f7d7712cdf Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 14:29:54 -0400
Subject: [PATCH 064/143] Added check for objective option in constructor

Added test as well.
---
 pyomo/contrib/doe/grey_box_utilities.py |  8 +++-----
 pyomo/contrib/doe/tests/test_greybox.py | 17 +++++++++++++++++
 2 files changed, 20 insertions(+), 5 deletions(-)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index e2d8e2794e9..828ce386170 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -73,12 +73,10 @@ def __init__(self, doe_object, objective_option="determinant", logger_level=None
         # Check if the doe_object has model components that are required
         # TODO: add checks for the model --> doe_object.model needs FIM; all other checks should
         #       have been satisfied before the FIM is created. Can add check for unknown_parameters...
-        if objective_option == "determinant":
-            from pyomo.contrib.doe import ObjectiveLib
-
-            objective_option = ObjectiveLib(objective_option)
+        from pyomo.contrib.doe import ObjectiveLib
+        objective_option = ObjectiveLib(objective_option)
         self.objective_option = (
-            objective_option  # Add failsafe to make sure this is ObjectiveLib object?
+            objective_option
         )
         # Will anyone ever call this without calling DoE? --> intended to be no; but maybe more utility?
 
diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index a8dacdb52fb..21fe6dc31e3 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -869,6 +869,23 @@ def test_ME_opt_greybox_build(self):
         current_FIM += current_FIM.transpose() - np.diag(np.diag(current_FIM))
 
         self.assertTrue(np.all(np.isclose(current_FIM, testing_matrix + np.eye(4))))
+    
+    # Testing all the error messages
+    def test_constructor_doe_object_error(self):
+        with self.assertRaisesRegex(
+            ValueError,
+            "DoE Object must be provided to build external grey box of the FIM.",
+        ):
+            grey_box_object = FIMExternalGreyBox(doe_object=None)
+
+    def test_constructor_objective_lib_error(self):
+        objective_option = "trace"
+        doe_object, grey_box_object = make_greybox_and_doe_objects(objective_option=objective_option)
+        with self.assertRaisesRegex(
+            ValueError,
+            "'Bad Objective Option' is not a valid ObjectiveLib",
+        ):
+            bad_grey_box_object = FIMExternalGreyBox(doe_object=doe_object, objective_option="Bad Objective Option")
 
 
 if __name__ == "__main__":

From 19315824f2839d9115e56430bed616e78b7bc18f Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 14:30:09 -0400
Subject: [PATCH 065/143] Ran black

---
 pyomo/contrib/doe/grey_box_utilities.py |  5 ++---
 pyomo/contrib/doe/tests/test_greybox.py | 13 ++++++++-----
 2 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index 828ce386170..f52d98070ba 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -74,10 +74,9 @@ def __init__(self, doe_object, objective_option="determinant", logger_level=None
         # TODO: add checks for the model --> doe_object.model needs FIM; all other checks should
         #       have been satisfied before the FIM is created. Can add check for unknown_parameters...
         from pyomo.contrib.doe import ObjectiveLib
+
         objective_option = ObjectiveLib(objective_option)
-        self.objective_option = (
-            objective_option
-        )
+        self.objective_option = objective_option
         # Will anyone ever call this without calling DoE? --> intended to be no; but maybe more utility?
 
         # Create logger for FIM egb object
diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 21fe6dc31e3..b3febf62070 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -869,7 +869,7 @@ def test_ME_opt_greybox_build(self):
         current_FIM += current_FIM.transpose() - np.diag(np.diag(current_FIM))
 
         self.assertTrue(np.all(np.isclose(current_FIM, testing_matrix + np.eye(4))))
-    
+
     # Testing all the error messages
     def test_constructor_doe_object_error(self):
         with self.assertRaisesRegex(
@@ -880,12 +880,15 @@ def test_constructor_doe_object_error(self):
 
     def test_constructor_objective_lib_error(self):
         objective_option = "trace"
-        doe_object, grey_box_object = make_greybox_and_doe_objects(objective_option=objective_option)
+        doe_object, grey_box_object = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
         with self.assertRaisesRegex(
-            ValueError,
-            "'Bad Objective Option' is not a valid ObjectiveLib",
+            ValueError, "'Bad Objective Option' is not a valid ObjectiveLib"
         ):
-            bad_grey_box_object = FIMExternalGreyBox(doe_object=doe_object, objective_option="Bad Objective Option")
+            bad_grey_box_object = FIMExternalGreyBox(
+                doe_object=doe_object, objective_option="Bad Objective Option"
+            )
 
 
 if __name__ == "__main__":

From 472fedac4479ac89ceceb0616c4c622fa587dabe Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 14:32:40 -0400
Subject: [PATCH 066/143] Adding objective errors using Enum messages.

---
 pyomo/contrib/doe/grey_box_utilities.py | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index f52d98070ba..051aaca1db3 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -145,6 +145,10 @@ def output_names(self):
             obj_name = "E-opt"
         elif self.objective_option == ObjectiveLib.condition_number:
             obj_name = "ME-opt"
+        else:
+            raise AttributeError(
+                "Objective option not recognized. Please contact the developers as you should not see this error."
+            )
         return [obj_name]
 
     def set_input_values(self, input_values):
@@ -180,6 +184,10 @@ def evaluate_outputs(self):
         elif self.objective_option == ObjectiveLib.condition_number:
             eig, _ = np.linalg.eig(M)
             obj_value = np.max(eig) / np.min(eig)
+        else:
+            raise AttributeError(
+                "Objective option not recognized. Please contact the developers as you should not see this error."
+            )
 
         # print(obj_value)
 
@@ -212,6 +220,10 @@ def finalize_block_construction(self, pyomo_block):
             pyomo_block.outputs["E-opt"] = output_value
         elif self.objective_option == ObjectiveLib.condition_number:
             pyomo_block.outputs["ME-opt"] = output_value
+        else:
+            raise AttributeError(
+                "Objective option not recognized. Please contact the developers as you should not see this error."
+            )
 
     def evaluate_jacobian_equality_constraints(self):
         # ToDo: Do any objectives require constraints?
@@ -309,6 +321,10 @@ def evaluate_jacobian_outputs(self):
                 / (min_eig + np.sign(min_eig) * min_eig_epsilon)
                 * (max_eig_term - safe_cond_number * min_eig_term)
             )
+        else:
+            raise AttributeError(
+                "Objective option not recognized. Please contact the developers as you should not see this error."
+            )
 
         # print(jac_M)
         # Filter jac_M using the
@@ -500,6 +516,10 @@ def evaluate_hessian_outputs(self, FIM=None):
                 hess_cols.append(col)
         elif self.objective_option == ObjectiveLib.condition_number:
             pass
+        else:
+            raise AttributeError(
+                "Objective option not recognized. Please contact the developers as you should not see this error."
+            )
 
         # Returns coo_matrix of the correct shape
         return coo_matrix(

From 2177d5c4e6bf59bf338b8d5394f8e1d25e2bb292 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 14:39:23 -0400
Subject: [PATCH 067/143] Added 4 tests for bad objective lib options

---
 pyomo/contrib/doe/grey_box_utilities.py | 20 ++--------
 pyomo/contrib/doe/tests/test_greybox.py | 51 +++++++++++++++++++++++++
 2 files changed, 55 insertions(+), 16 deletions(-)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index 051aaca1db3..5889e78f671 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -146,9 +146,7 @@ def output_names(self):
         elif self.objective_option == ObjectiveLib.condition_number:
             obj_name = "ME-opt"
         else:
-            raise AttributeError(
-                "Objective option not recognized. Please contact the developers as you should not see this error."
-            )
+            ObjectiveLib(self.objective_option)
         return [obj_name]
 
     def set_input_values(self, input_values):
@@ -185,9 +183,7 @@ def evaluate_outputs(self):
             eig, _ = np.linalg.eig(M)
             obj_value = np.max(eig) / np.min(eig)
         else:
-            raise AttributeError(
-                "Objective option not recognized. Please contact the developers as you should not see this error."
-            )
+            ObjectiveLib(self.objective_option)
 
         # print(obj_value)
 
@@ -220,10 +216,6 @@ def finalize_block_construction(self, pyomo_block):
             pyomo_block.outputs["E-opt"] = output_value
         elif self.objective_option == ObjectiveLib.condition_number:
             pyomo_block.outputs["ME-opt"] = output_value
-        else:
-            raise AttributeError(
-                "Objective option not recognized. Please contact the developers as you should not see this error."
-            )
 
     def evaluate_jacobian_equality_constraints(self):
         # ToDo: Do any objectives require constraints?
@@ -322,9 +314,7 @@ def evaluate_jacobian_outputs(self):
                 * (max_eig_term - safe_cond_number * min_eig_term)
             )
         else:
-            raise AttributeError(
-                "Objective option not recognized. Please contact the developers as you should not see this error."
-            )
+            ObjectiveLib(self.objective_option)
 
         # print(jac_M)
         # Filter jac_M using the
@@ -517,9 +507,7 @@ def evaluate_hessian_outputs(self, FIM=None):
         elif self.objective_option == ObjectiveLib.condition_number:
             pass
         else:
-            raise AttributeError(
-                "Objective option not recognized. Please contact the developers as you should not see this error."
-            )
+            ObjectiveLib(self.objective_option)
 
         # Returns coo_matrix of the correct shape
         return coo_matrix(
diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index b3febf62070..1383a283312 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -890,6 +890,57 @@ def test_constructor_objective_lib_error(self):
                 doe_object=doe_object, objective_option="Bad Objective Option"
             )
 
+    def test_output_names_obj_lib_error(self):
+        objective_option = "trace"
+        doe_object, grey_box_object = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
+
+        grey_box_object.objective_option = "Bad Objective Option"
+
+        with self.assertRaisesRegex(
+            ValueError, "'Bad Objective Option' is not a valid ObjectiveLib"
+        ):
+            grey_box_object.output_names()
+    
+    def test_evaluate_outputs_obj_lib_error(self):
+        objective_option = "trace"
+        doe_object, grey_box_object = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
+
+        grey_box_object.objective_option = "Bad Objective Option"
+
+        with self.assertRaisesRegex(
+            ValueError, "'Bad Objective Option' is not a valid ObjectiveLib"
+        ):
+            grey_box_object.evaluate_outputs()
+
+    def test_evaluate_jacobian_outputs_obj_lib_error(self):
+        objective_option = "trace"
+        doe_object, grey_box_object = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
+
+        grey_box_object.objective_option = "Bad Objective Option"
+
+        with self.assertRaisesRegex(
+            ValueError, "'Bad Objective Option' is not a valid ObjectiveLib"
+        ):
+            grey_box_object.evaluate_jacobian_outputs()
+
+    def test_evaluate_hessian_outputs_obj_lib_error(self):
+        objective_option = "trace"
+        doe_object, grey_box_object = make_greybox_and_doe_objects(
+            objective_option=objective_option
+        )
+
+        grey_box_object.objective_option = "Bad Objective Option"
+
+        with self.assertRaisesRegex(
+            ValueError, "'Bad Objective Option' is not a valid ObjectiveLib"
+        ):
+            grey_box_object.evaluate_hessian_outputs()
 
 if __name__ == "__main__":
     unittest.main()

From ea96bedf05054b2de9708d3154b9db8da526f7a3 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 15 May 2025 14:39:38 -0400
Subject: [PATCH 068/143] Ran black

---
 pyomo/contrib/doe/tests/test_greybox.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 1383a283312..08d1991d15e 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -902,7 +902,7 @@ def test_output_names_obj_lib_error(self):
             ValueError, "'Bad Objective Option' is not a valid ObjectiveLib"
         ):
             grey_box_object.output_names()
-    
+
     def test_evaluate_outputs_obj_lib_error(self):
         objective_option = "trace"
         doe_object, grey_box_object = make_greybox_and_doe_objects(
@@ -942,5 +942,6 @@ def test_evaluate_hessian_outputs_obj_lib_error(self):
         ):
             grey_box_object.evaluate_hessian_outputs()
 
+
 if __name__ == "__main__":
     unittest.main()

From e4c99b4dabd4755804a4f59ea37bd52330ac1e62 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Fri, 16 May 2025 07:15:28 -0400
Subject: [PATCH 069/143] Relaxed the numpy `isclose` tolerances

---
 pyomo/contrib/doe/tests/test_greybox.py | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 08d1991d15e..b84003ad78d 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -492,7 +492,7 @@ def test_jacobian_A_opt(self):
         jac_FD = get_numerical_derivative(grey_box_object)
 
         # assert that each component is close
-        self.assertTrue(np.all(np.isclose(jac, jac_FD)))
+        self.assertTrue(np.all(np.isclose(jac, jac_FD, rtol=1e-4, atol=1e-4)))
 
     def test_jacobian_D_opt(self):
         objective_option = "determinant"
@@ -515,7 +515,7 @@ def test_jacobian_D_opt(self):
         jac_FD = get_numerical_derivative(grey_box_object)
 
         # assert that each component is close
-        self.assertTrue(np.all(np.isclose(jac, jac_FD)))
+        self.assertTrue(np.all(np.isclose(jac, jac_FD, rtol=1e-4, atol=1e-4)))
 
     def test_jacobian_E_opt(self):
         objective_option = "minimum_eigenvalue"
@@ -538,7 +538,7 @@ def test_jacobian_E_opt(self):
         jac_FD = get_numerical_derivative(grey_box_object)
 
         # assert that each component is close
-        self.assertTrue(np.all(np.isclose(jac, jac_FD)))
+        self.assertTrue(np.all(np.isclose(jac, jac_FD, rtol=1e-4, atol=1e-4)))
 
     def test_jacobian_ME_opt(self):
         objective_option = "condition_number"
@@ -561,7 +561,7 @@ def test_jacobian_ME_opt(self):
         jac_FD = get_numerical_derivative(grey_box_object)
 
         # assert that each component is close
-        self.assertTrue(np.all(np.isclose(jac, jac_FD)))
+        self.assertTrue(np.all(np.isclose(jac, jac_FD, rtol=1e-4, atol=1e-4)))
 
     # Testing Hessian Computation
     def test_hessian_A_opt(self):
@@ -584,7 +584,7 @@ def test_hessian_A_opt(self):
         hess_FD = get_numerical_second_derivative(grey_box_object)
 
         # assert that each component is close
-        self.assertTrue(np.all(np.isclose(hess_gb, hess_FD)))
+        self.assertTrue(np.all(np.isclose(hess_gb, hess_FD, rtol=1e-4, atol=1e-4)))
 
     def test_hessian_D_opt(self):
         objective_option = "determinant"
@@ -606,7 +606,7 @@ def test_hessian_D_opt(self):
         hess_FD = get_numerical_second_derivative(grey_box_object)
 
         # assert that each component is close
-        self.assertTrue(np.all(np.isclose(hess_gb, hess_FD)))
+        self.assertTrue(np.all(np.isclose(hess_gb, hess_FD, rtol=1e-4, atol=1e-4)))
 
     def test_hessian_E_opt(self):
         objective_option = "minimum_eigenvalue"
@@ -628,7 +628,7 @@ def test_hessian_E_opt(self):
         hess_FD = get_numerical_second_derivative(grey_box_object)
 
         # assert that each component is close
-        self.assertTrue(np.all(np.isclose(hess_gb, hess_FD)))
+        self.assertTrue(np.all(np.isclose(hess_gb, hess_FD, rtol=1e-4, atol=1e-4)))
 
     def test_equality_constraint_names(self):
         objective_option = "condition_number"

From 0085c76c330e0313055b430bfdc644aafb97f514 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Fri, 16 May 2025 08:28:05 -0400
Subject: [PATCH 070/143] Trying to make vanilla det solve more stable

---
 pyomo/contrib/doe/tests/test_doe_solve.py | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/pyomo/contrib/doe/tests/test_doe_solve.py b/pyomo/contrib/doe/tests/test_doe_solve.py
index 83884be0b2c..0548e1beedc 100644
--- a/pyomo/contrib/doe/tests/test_doe_solve.py
+++ b/pyomo/contrib/doe/tests/test_doe_solve.py
@@ -188,6 +188,9 @@ def test_reactor_fd_backward_solve(self):
         # Make sure FIM and Q.T @ sigma_inv @ Q are close (alternate definition of FIM)
         self.assertTrue(np.all(np.isclose(FIM, Q.T @ sigma_inv @ Q)))
 
+    @unittest.skipIf(
+        not k_aug_available.available(False), "The 'k_aug' command is not available"
+    )
     def test_reactor_obj_det_solve(self):
         fd_method = "central"
         obj_used = "determinant"
@@ -203,6 +206,10 @@ def test_reactor_obj_det_solve(self):
 
         doe_obj = DesignOfExperiments(**DoE_args)
 
+        # Increase numerical performance by adding a prior
+        prior_FIM = doe_obj.compute_FIM()
+        doe_obj.prior_FIM = prior_FIM
+
         doe_obj.run_doe()
 
         self.assertEqual(doe_obj.results['Solver Status'], "ok")

From 3567ad24650ff171a416b2f985a4fb690847dc50 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Wed, 21 May 2025 14:45:46 -0400
Subject: [PATCH 071/143] Make sure the hessian is lower triangular

---
 pyomo/contrib/doe/grey_box_utilities.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index 5889e78f671..f8795a48d12 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -400,8 +400,8 @@ def evaluate_hessian_outputs(self, FIM=None):
                 # Col will be the location of the
                 # second ordered pair (d2) in input names
                 d1, d2 = current_differential
-                row = self.input_names().index(d1)
-                col = self.input_names().index(d2)
+                row = self.input_names().index(d2)
+                col = self.input_names().index(d1)
 
                 # Grabbing the ordered quadruple (i, j, k, l)
                 # `location` here refers to the index in the
@@ -433,8 +433,8 @@ def evaluate_hessian_outputs(self, FIM=None):
                 # obtained identically as in the trace
                 # for loop above.
                 d1, d2 = current_differential
-                row = self.input_names().index(d1)
-                col = self.input_names().index(d2)
+                row = self.input_names().index(d2)
+                col = self.input_names().index(d1)
 
                 i = self._param_names.index(d1[0])
                 j = self._param_names.index(d1[1])
@@ -462,8 +462,8 @@ def evaluate_hessian_outputs(self, FIM=None):
                 # obtained identically as in the trace
                 # for loop above.
                 d1, d2 = current_differential
-                row = self.input_names().index(d1)
-                col = self.input_names().index(d2)
+                row = self.input_names().index(d2)
+                col = self.input_names().index(d1)
 
                 i = self._param_names.index(d1[0])
                 j = self._param_names.index(d1[1])

From 7913064405659dd5d66b031ba5852199902a0519 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Wed, 21 May 2025 14:46:07 -0400
Subject: [PATCH 072/143] Remove forcing MUMPS as linear solver for tests

---
 pyomo/contrib/doe/tests/test_greybox.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index b84003ad78d..3dde1a56b11 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -290,7 +290,7 @@ def get_standard_args(experiment, fd_method, obj_used):
     args['L_diagonal_lower_bound'] = 1e-7
     # Change when we can access other solvers
     solver = SolverFactory("ipopt")
-    solver.options["linear_solver"] = "MUMPS"
+    # solver.options["linear_solver"] = "MUMPS"
     args['solver'] = solver
     args['tee'] = False
     args['get_labeled_model_args'] = None

From 61c002c301888a7a8b43abb2a826f622eecb474c Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Wed, 21 May 2025 14:46:25 -0400
Subject: [PATCH 073/143] Changing default solver options for debugging

---
 pyomo/contrib/doe/doe.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index fc490a3d5d7..44c271d8a9b 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -211,7 +211,7 @@ def __init__(
             # solver.options["linear_solver"] = "MUMPS"
             solver.options["halt_on_ampl_error"] = "yes"
             solver.options["max_iter"] = 3000
-            # solver.options["tol"] = 1e-4
+            solver.options["tol"] = 1e-5
             self.solver = solver
 
         self.tee = tee
@@ -221,10 +221,10 @@ def __init__(
             self.grey_box_solver = grey_box_solver
         else:
             grey_box_solver = pyo.SolverFactory("cyipopt")
-            grey_box_solver.config.options['hessian_approximation'] = 'limited-memory'
-            # grey_box_solver.config.options["linear_solver"] = "ma57"
-            grey_box_solver.config.options['max_iter'] = 200
-            grey_box_solver.config.options['tol'] = 1e-4
+            # grey_box_solver.config.options['hessian_approximation'] = 'limited-memory'
+            grey_box_solver.config.options["linear_solver"] = "ma57"
+            grey_box_solver.config.options['max_iter'] = 1000
+            grey_box_solver.config.options['tol'] = 1e-5
             # grey_box_solver.config.options['mu_strategy'] = "monotone"
 
             self.grey_box_solver = grey_box_solver

From e1c8b32dccf3bf0a376b284afd6c09f71cf4029e Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Wed, 21 May 2025 15:57:03 -0400
Subject: [PATCH 074/143] Remove rogue debugging print statement

---
 pyomo/contrib/doe/doe.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index 44c271d8a9b..46bf6fcb246 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -351,7 +351,6 @@ def run_doe(self, model=None, results_file=None):
                         model.obj_cons.egb_fim_block.inputs[(j, i)].set_value(
                             pyo.value(model.fim[(i, j)])
                         )
-                        print(j, i)
                     else:  # REMOVE THIS IF USING LOWER TRIANGLE
                         pass
                         # model.obj_cons.egb_fim_block.inputs[(j, i)].set_value(

From e4ee26cbb2542eefc27bab8ce63811dd829447b3 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 22 May 2025 08:31:41 -0400
Subject: [PATCH 075/143] Trying some solver conditions for grey box

---
 pyomo/contrib/doe/doe.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index 46bf6fcb246..ebda8123e64 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -223,9 +223,9 @@ def __init__(
             grey_box_solver = pyo.SolverFactory("cyipopt")
             # grey_box_solver.config.options['hessian_approximation'] = 'limited-memory'
             grey_box_solver.config.options["linear_solver"] = "ma57"
-            grey_box_solver.config.options['max_iter'] = 1000
-            grey_box_solver.config.options['tol'] = 1e-5
-            # grey_box_solver.config.options['mu_strategy'] = "monotone"
+            #grey_box_solver.config.options['max_iter'] = 1000
+            grey_box_solver.config.options['tol'] = 1e-4
+            grey_box_solver.config.options['mu_strategy'] = "monotone"
 
             self.grey_box_solver = grey_box_solver
 

From ee4122cba510c97170f990d9d54406b301ae95e4 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 22 May 2025 08:32:07 -0400
Subject: [PATCH 076/143] Removing default mumps solving

---
 pyomo/contrib/doe/examples/grey_box_E_opt.py  | 2 +-
 pyomo/contrib/doe/examples/grey_box_ME_opt.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/pyomo/contrib/doe/examples/grey_box_E_opt.py b/pyomo/contrib/doe/examples/grey_box_E_opt.py
index 4cf58f5cb67..b082f73345d 100644
--- a/pyomo/contrib/doe/examples/grey_box_E_opt.py
+++ b/pyomo/contrib/doe/examples/grey_box_E_opt.py
@@ -48,7 +48,7 @@ def compare_reactor_doe():
     scale_nominal_param_value = True
 
     solver = pyo.SolverFactory("ipopt")
-    solver.options["linear_solver"] = "mumps"
+    #solver.options["linear_solver"] = "mumps"
 
     # DoE object to compute FIM prior
     # doe_obj = DesignOfExperiments(
diff --git a/pyomo/contrib/doe/examples/grey_box_ME_opt.py b/pyomo/contrib/doe/examples/grey_box_ME_opt.py
index accc1362d31..a2386119a36 100644
--- a/pyomo/contrib/doe/examples/grey_box_ME_opt.py
+++ b/pyomo/contrib/doe/examples/grey_box_ME_opt.py
@@ -48,7 +48,7 @@ def compare_reactor_doe():
     scale_nominal_param_value = True
 
     solver = pyo.SolverFactory("ipopt")
-    solver.options["linear_solver"] = "mumps"
+    #solver.options["linear_solver"] = "mumps"
 
     # DoE object to compute FIM prior
     doe_obj = DesignOfExperiments(

From 4374bccdcd3d2e8c6ae7f71400e2cbfaa9810757 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 22 May 2025 08:32:19 -0400
Subject: [PATCH 077/143] Added prior for grey box comparison

---
 pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py b/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
index 3122beba371..4139f2043bc 100644
--- a/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
+++ b/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
@@ -72,6 +72,9 @@ def compare_reactor_doe():
         _only_compute_fim_lower=True,
     )
 
+    prior_FIM = doe_obj.compute_FIM(method='sequential')
+    doe_obj.prior_FIM = prior_FIM
+    
     # Begin optimal DoE
     ####################
     doe_obj.run_doe()
@@ -110,7 +113,7 @@ def compare_reactor_doe():
         use_grey_box_objective=True,  # New object with grey box set to True
         scale_constant_value=1,
         scale_nominal_param_value=scale_nominal_param_value,
-        prior_FIM=None,
+        prior_FIM=prior_FIM,
         jac_initial=None,
         fim_initial=None,
         L_diagonal_lower_bound=1e-7,

From fe56da099ec1dd521f2576a6b3b29673090e2741 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 22 May 2025 08:32:47 -0400
Subject: [PATCH 078/143] Adjusting initial point to be close to D-optimal

---
 pyomo/contrib/doe/examples/result.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyomo/contrib/doe/examples/result.json b/pyomo/contrib/doe/examples/result.json
index 7e1b1a79a1b..8387b7524d8 100644
--- a/pyomo/contrib/doe/examples/result.json
+++ b/pyomo/contrib/doe/examples/result.json
@@ -1 +1 @@
-{"CA0": 5.0, "CA_bounds": [1.0, 5.0], "CB0": 0.0, "CC0": 0.0, "t_range": [0, 1], "control_points": {"0": 500, "0.125": 300, "0.25": 300, "0.375": 300, "0.5": 300, "0.625": 300, "0.75": 300, "0.875": 300, "1": 300}, "T_bounds": [300, 700], "A1": 84.79, "A2": 371.72, "E1": 7.78, "E2": 15.05}
\ No newline at end of file
+{"CA0": 5.0, "CA_bounds": [1.0, 5.0], "CB0": 0.0, "CC0": 0.0, "t_range": [0, 1], "control_points": {"0": 481.5, "0.125": 300, "0.25": 300, "0.375": 300, "0.5": 300, "0.625": 300, "0.75": 300, "0.875": 300, "1": 300}, "T_bounds": [300, 700], "A1": 84.79, "A2": 371.72, "E1": 7.78, "E2": 15.05}

From bf94c3018efd7a2c2a771e913cea4ac897cb2576 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 22 May 2025 08:39:31 -0400
Subject: [PATCH 079/143] Ran Black

---
 pyomo/contrib/doe/doe.py                                | 2 +-
 pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py | 2 +-
 pyomo/contrib/doe/examples/grey_box_E_opt.py            | 2 +-
 pyomo/contrib/doe/examples/grey_box_ME_opt.py           | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index 9a936a45ca0..ea8c8f23446 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -223,7 +223,7 @@ def __init__(
             grey_box_solver = pyo.SolverFactory("cyipopt")
             # grey_box_solver.config.options['hessian_approximation'] = 'limited-memory'
             grey_box_solver.config.options["linear_solver"] = "ma57"
-            #grey_box_solver.config.options['max_iter'] = 1000
+            # grey_box_solver.config.options['max_iter'] = 1000
             grey_box_solver.config.options['tol'] = 1e-4
             grey_box_solver.config.options['mu_strategy'] = "monotone"
 
diff --git a/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py b/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
index 4139f2043bc..61027e10dd8 100644
--- a/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
+++ b/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
@@ -74,7 +74,7 @@ def compare_reactor_doe():
 
     prior_FIM = doe_obj.compute_FIM(method='sequential')
     doe_obj.prior_FIM = prior_FIM
-    
+
     # Begin optimal DoE
     ####################
     doe_obj.run_doe()
diff --git a/pyomo/contrib/doe/examples/grey_box_E_opt.py b/pyomo/contrib/doe/examples/grey_box_E_opt.py
index b082f73345d..bdb0f6f6cd1 100644
--- a/pyomo/contrib/doe/examples/grey_box_E_opt.py
+++ b/pyomo/contrib/doe/examples/grey_box_E_opt.py
@@ -48,7 +48,7 @@ def compare_reactor_doe():
     scale_nominal_param_value = True
 
     solver = pyo.SolverFactory("ipopt")
-    #solver.options["linear_solver"] = "mumps"
+    # solver.options["linear_solver"] = "mumps"
 
     # DoE object to compute FIM prior
     # doe_obj = DesignOfExperiments(
diff --git a/pyomo/contrib/doe/examples/grey_box_ME_opt.py b/pyomo/contrib/doe/examples/grey_box_ME_opt.py
index a2386119a36..cca0c0a09dc 100644
--- a/pyomo/contrib/doe/examples/grey_box_ME_opt.py
+++ b/pyomo/contrib/doe/examples/grey_box_ME_opt.py
@@ -48,7 +48,7 @@ def compare_reactor_doe():
     scale_nominal_param_value = True
 
     solver = pyo.SolverFactory("ipopt")
-    #solver.options["linear_solver"] = "mumps"
+    # solver.options["linear_solver"] = "mumps"
 
     # DoE object to compute FIM prior
     doe_obj = DesignOfExperiments(

From 019fbc783f310109e5dbe16db13444920be32b1c Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Fri, 23 May 2025 08:19:44 -0400
Subject: [PATCH 080/143] Added simple rooney biegler example for DoE

This is slightly different than the parmest experiments as we need measurement error as well as experiment inputs for this one. Also, we wanted to separate data points as individual experiments.
---
 .../doe/examples/rooney_biegler_example.py    | 147 ++++++++++++++++++
 .../doe/examples/rooney_biegler_experiment.py | 100 ++++++++++++
 2 files changed, 247 insertions(+)
 create mode 100644 pyomo/contrib/doe/examples/rooney_biegler_example.py
 create mode 100644 pyomo/contrib/doe/examples/rooney_biegler_experiment.py

diff --git a/pyomo/contrib/doe/examples/rooney_biegler_example.py b/pyomo/contrib/doe/examples/rooney_biegler_example.py
new file mode 100644
index 00000000000..b469f6a5c2b
--- /dev/null
+++ b/pyomo/contrib/doe/examples/rooney_biegler_example.py
@@ -0,0 +1,147 @@
+#  ___________________________________________________________________________
+#
+#  Pyomo: Python Optimization Modeling Objects
+#  Copyright (c) 2008-2025
+#  National Technology and Engineering Solutions of Sandia, LLC
+#  Under the terms of Contract DE-NA0003525 with National Technology and
+#  Engineering Solutions of Sandia, LLC, the U.S. Government retains certain
+#  rights in this software.
+#  This software is distributed under the 3-clause BSD License.
+#  ___________________________________________________________________________
+"""
+Rooney Biegler model, based on Rooney, W. C. and Biegler, L. T. (2001). Design for
+model parameter uncertainty using nonlinear confidence regions. AIChE Journal,
+47(8), 1794-1804.
+"""
+from pyomo.common.dependencies import numpy as np, pathlib
+
+from pyomo.contrib.doe.examples.rooney_biegler_experiment import (
+    RooneyBieglerExperimentDoE,
+)
+from pyomo.contrib.doe import DesignOfExperiments
+
+import pyomo.environ as pyo
+
+import matplotlib.pyplot as plt
+import json
+import sys
+
+
+# Example for sensitivity analysis on the reactor experiment
+# After sensitivity analysis is done, we perform optimal DoE
+def run_rooney_biegler_doe():
+    # Create a RooneyBiegler Experiment
+    experiment = RooneyBieglerExperimentDoE(data={'hour': 2, 'y': 10.3})
+
+    # Use a central difference, with step size 1e-3
+    fd_formula = "central"
+    step_size = 1e-3
+
+    # Use the determinant objective with scaled sensitivity matrix
+    objective_option = "determinant"
+    scale_nominal_param_value = True
+
+    data = [[1, 8.3], [7, 19.8], [2, 10.3], [5, 15.6], [3, 19.0], [4, 16.0]]
+    FIM_prior = np.zeros((2, 2))
+    # Calculate prior using existing experiments
+    for i in range(len(data)):
+        if i > int(sys.argv[1]):
+            break
+        prev_experiment = RooneyBieglerExperimentDoE(
+            data={'hour': data[i][0], 'y': data[i][1]}
+        )
+        doe_obj = DesignOfExperiments(
+            prev_experiment,
+            fd_formula=fd_formula,
+            step=step_size,
+            objective_option=objective_option,
+            scale_nominal_param_value=scale_nominal_param_value,
+            prior_FIM=None,
+            tee=False,
+        )
+
+        FIM_prior += doe_obj.compute_FIM(method='sequential')
+
+    if sys.argv[1] == 0:
+        FIM_prior[0][0] += 1e-6
+        FIM_prior[1][1] += 1e-6
+
+    # Create the DesignOfExperiments object
+    # We will not be passing any prior information in this example
+    # and allow the experiment object and the DesignOfExperiments
+    # call of ``run_doe`` perform model initialization.
+    doe_obj = DesignOfExperiments(
+        experiment,
+        fd_formula=fd_formula,
+        step=step_size,
+        objective_option=objective_option,
+        scale_constant_value=1,
+        scale_nominal_param_value=scale_nominal_param_value,
+        prior_FIM=FIM_prior,
+        jac_initial=None,
+        fim_initial=None,
+        L_diagonal_lower_bound=1e-7,
+        solver=None,
+        tee=False,
+        get_labeled_model_args=None,
+        _Cholesky_option=True,
+        _only_compute_fim_lower=True,
+    )
+
+    # Begin optimal DoE
+    ####################
+    doe_obj.run_doe()
+
+    # Print out a results summary
+    print("Optimal experiment values: ")
+    print(
+        "\tOptimal measurement time: {:.2f}".format(
+            doe_obj.results["Experiment Design"][0]
+        )
+    )
+    print("FIM at optimal design:\n {}".format(np.array(doe_obj.results["FIM"])))
+    print(
+        "Objective value at optimal design: {:.2f}".format(
+            pyo.value(doe_obj.model.objective)
+        )
+    )
+
+    print(doe_obj.results["Experiment Design Names"])
+
+    ###################
+    # End optimal DoE
+
+    # Begin optimal greybox DoE
+    ############################
+    doe_obj_gb = DesignOfExperiments(
+        experiment,
+        fd_formula=fd_formula,
+        step=step_size,
+        objective_option=objective_option,
+        use_grey_box_objective=True,
+        scale_nominal_param_value=scale_nominal_param_value,
+        prior_FIM=FIM_prior,
+        tee=False,
+    )
+
+    doe_obj_gb.run_doe()
+
+    print("Optimal experiment values: ")
+    print(
+        "\tOptimal measurement time: {:.2f}".format(
+            doe_obj_gb.results["Experiment Design"][0]
+        )
+    )
+    print("FIM at optimal design:\n {}".format(np.array(doe_obj_gb.results["FIM"])))
+    print(
+        "Objective value at optimal design: {:.2f}".format(
+            np.log10(np.exp(pyo.value(doe_obj_gb.model.objective)))
+        )
+    )
+
+    ############################
+    # End optimal greybox DoE
+
+
+if __name__ == "__main__":
+    run_rooney_biegler_doe()
diff --git a/pyomo/contrib/doe/examples/rooney_biegler_experiment.py b/pyomo/contrib/doe/examples/rooney_biegler_experiment.py
new file mode 100644
index 00000000000..4918100b78d
--- /dev/null
+++ b/pyomo/contrib/doe/examples/rooney_biegler_experiment.py
@@ -0,0 +1,100 @@
+#  ___________________________________________________________________________
+#
+#  Pyomo: Python Optimization Modeling Objects
+#  Copyright (c) 2008-2025
+#  National Technology and Engineering Solutions of Sandia, LLC
+#  Under the terms of Contract DE-NA0003525 with National Technology and
+#  Engineering Solutions of Sandia, LLC, the U.S. Government retains certain
+#  rights in this software.
+#  This software is distributed under the 3-clause BSD License.
+#  ___________________________________________________________________________
+
+"""
+Rooney Biegler model, based on Rooney, W. C. and Biegler, L. T. (2001). Design for
+model parameter uncertainty using nonlinear confidence regions. AIChE Journal,
+47(8), 1794-1804.
+"""
+
+from pyomo.common.dependencies import pandas as pd
+import pyomo.environ as pyo
+from pyomo.contrib.parmest.experiment import Experiment
+
+
+class RooneyBieglerExperimentDoE(Experiment):
+    def __init__(self, data=None, theta=None):
+        if data is None:
+            self.data = {}
+            self.data['hour'] = 1
+            self.data['y'] = 8.3
+        else:
+            self.data = data
+        if theta is None:
+            self.theta = {}
+            self.theta['asymptote'] = 19.143
+            self.theta['rate constant'] = 0.5311
+        else:
+            self.theta = theta
+        self.model = None
+
+    def create_model(self):
+        # Creates Roony-Biegler model for
+        # individual data points as
+        # an experimental decision.
+        m = self.model = pyo.ConcreteModel()
+
+        # Specify the unknown parameters
+        m.asymptote = pyo.Var(initialize=self.theta['asymptote'])
+        m.rate_constant = pyo.Var(initialize=self.theta['rate constant'])
+
+        # Fix the unknown parameters
+        m.asymptote.fix()
+        m.rate_constant.fix()
+
+        # Add the experiment inputs
+        m.hour = pyo.Var(initialize=self.data['hour'], bounds=(0, 10))
+
+        # Fix the experimental design variable
+        m.hour.fix()
+
+        # Add the experiment outputs
+        m.y = pyo.Var(initialize=self.data['y'])
+
+        # Add governing equation
+        m.response_function = pyo.Constraint(
+            expr=m.y - m.asymptote * (1 - pyo.exp(-m.rate_constant * m.hour)) == 0
+        )
+
+    def finalize_model(self):
+        m = self.model
+        pass
+
+    def label_model(self):
+        m = self.model
+
+        # Add y value as experiment output
+        m.experiment_outputs = pyo.Suffix(direction=pyo.Suffix.LOCAL)
+        m.experiment_outputs[m.y] = m.y()
+
+        # Add measurement error associated with y
+        # We are assuming a flat error of 0.3
+        # or about 1-3 percent
+        m.measurement_error = pyo.Suffix(direction=pyo.Suffix.LOCAL)
+        m.measurement_error[m.y] = 1
+
+        # Add hour as experiment input
+        # We are deciding when to sample
+        m.experiment_inputs = pyo.Suffix(direction=pyo.Suffix.LOCAL)
+        m.experiment_inputs[m.hour] = m.hour()
+
+        # Adding the unknown parameters
+        m.unknown_parameters = pyo.Suffix(direction=pyo.Suffix.LOCAL)
+        m.unknown_parameters.update(
+            (k, k.value) for k in [m.asymptote, m.rate_constant]
+        )
+
+    def get_labeled_model(self):
+        self.create_model()
+        self.finalize_model()
+        self.label_model()
+
+        return self.model

From 3e4b80ab1c738ecb76e4749c0edf8993ae4f0e7f Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Fri, 23 May 2025 08:21:37 -0400
Subject: [PATCH 081/143] Update comment to describe file.

---
 pyomo/contrib/doe/examples/rooney_biegler_example.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/pyomo/contrib/doe/examples/rooney_biegler_example.py b/pyomo/contrib/doe/examples/rooney_biegler_example.py
index b469f6a5c2b..ebc37a14d4e 100644
--- a/pyomo/contrib/doe/examples/rooney_biegler_example.py
+++ b/pyomo/contrib/doe/examples/rooney_biegler_example.py
@@ -27,8 +27,10 @@
 import sys
 
 
-# Example for sensitivity analysis on the reactor experiment
-# After sensitivity analysis is done, we perform optimal DoE
+# Example comparing Cholesky factorization
+# (standard solve) with grey box objective
+# solve for the log-deteriminant of the FIM
+# (D-optimality)
 def run_rooney_biegler_doe():
     # Create a RooneyBiegler Experiment
     experiment = RooneyBieglerExperimentDoE(data={'hour': 2, 'y': 10.3})

From cf0d7ef752e2ca1e48e26e94e18a9d4dc005bf91 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Fri, 23 May 2025 08:24:29 -0400
Subject: [PATCH 082/143] Get rid of unused code.

---
 pyomo/contrib/doe/tests/test_greybox.py | 57 -------------------------
 1 file changed, 57 deletions(-)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 3dde1a56b11..18e7b559322 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -219,63 +219,6 @@ def get_numerical_second_derivative(grey_box_object=None, return_reduced=True):
     return numerical_derivative
 
 
-def get_FIM_FIMPrior_Q_L(doe_obj=None):
-    """
-    Helper function to retrieve results to compare.
-
-    """
-    model = doe_obj.model
-
-    n_param = doe_obj.n_parameters
-    n_y = doe_obj.n_experiment_outputs
-
-    FIM_vals = [
-        pyo.value(model.fim[i, j])
-        for i in model.parameter_names
-        for j in model.parameter_names
-    ]
-    FIM_prior_vals = [
-        pyo.value(model.prior_FIM[i, j])
-        for i in model.parameter_names
-        for j in model.parameter_names
-    ]
-    if hasattr(model, "L"):
-        L_vals = [
-            pyo.value(model.L[i, j])
-            for i in model.parameter_names
-            for j in model.parameter_names
-        ]
-    else:
-        L_vals = [[0] * n_param] * n_param
-    Q_vals = [
-        pyo.value(model.sensitivity_jacobian[i, j])
-        for i in model.output_names
-        for j in model.parameter_names
-    ]
-    sigma_inv = [1 / v for k, v in model.scenario_blocks[0].measurement_error.items()]
-    param_vals = np.array(
-        [[v for k, v in model.scenario_blocks[0].unknown_parameters.items()]]
-    )
-
-    FIM_vals_np = np.array(FIM_vals).reshape((n_param, n_param))
-    FIM_prior_vals_np = np.array(FIM_prior_vals).reshape((n_param, n_param))
-
-    for i in range(n_param):
-        for j in range(n_param):
-            if j < i:
-                FIM_vals_np[j, i] = FIM_vals_np[i, j]
-
-    L_vals_np = np.array(L_vals).reshape((n_param, n_param))
-    Q_vals_np = np.array(Q_vals).reshape((n_y, n_param))
-
-    sigma_inv_np = np.zeros((n_y, n_y))
-
-    for ind, v in enumerate(sigma_inv):
-        sigma_inv_np[ind, ind] = v
-
-    return FIM_vals_np, FIM_prior_vals_np, Q_vals_np, L_vals_np, sigma_inv_np
-
-
 def get_standard_args(experiment, fd_method, obj_used):
     args = {}
     args['experiment'] = experiment

From bdc6441c0da5233d244b2b72c4f991f371b43776 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Fri, 23 May 2025 08:58:29 -0400
Subject: [PATCH 083/143] Added test for solving models with grey box

---
 pyomo/contrib/doe/tests/test_greybox.py | 189 +++++++++++++++++++++++-
 1 file changed, 187 insertions(+), 2 deletions(-)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 18e7b559322..e8fe81c8d3e 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -18,6 +18,7 @@
     numpy_available,
     pandas as pd,
     pandas_available,
+    scipy_available,
 )
 from pyomo.common.fileutils import this_file_dir
 import pyomo.common.unittest as unittest
@@ -26,6 +27,7 @@
 from pyomo.contrib.doe.examples.reactor_example import (
     ReactorExperiment as FullReactorExperiment,
 )
+from pyomo.contrib.doe.examples.rooney_biegler_example import RooneyBieglerExperimentDoE
 
 import pyomo.environ as pyo
 
@@ -231,9 +233,7 @@ def get_standard_args(experiment, fd_method, obj_used):
     args['jac_initial'] = None
     args['fim_initial'] = None
     args['L_diagonal_lower_bound'] = 1e-7
-    # Change when we can access other solvers
     solver = SolverFactory("ipopt")
-    # solver.options["linear_solver"] = "MUMPS"
     args['solver'] = solver
     args['tee'] = False
     args['get_labeled_model_args'] = None
@@ -262,8 +262,42 @@ def make_greybox_and_doe_objects(objective_option):
     return doe_obj, grey_box_object
 
 
+def make_greybox_and_doe_objects_rooney_biegler(objective_option):
+    fd_method = "central"
+    obj_used = objective_option
+
+    experiment = RooneyBieglerExperimentDoE(data={'hour': 2, 'y': 10.3})
+
+    DoE_args = get_standard_args(experiment, fd_method, obj_used)
+    DoE_args["use_grey_box_objective"] = True
+
+    data = [[1, 8.3], [7, 19.8]]
+    FIM_prior = np.zeros((2, 2))
+    # Calculate prior using existing experiments
+    for i in range(len(data)):
+        prev_experiment = RooneyBieglerExperimentDoE(
+            data={'hour': data[i][0], 'y': data[i][1]}
+        )
+        doe_obj = DesignOfExperiments(
+            **get_standard_args(prev_experiment, fd_method, obj_used)
+        )
+
+        FIM_prior += doe_obj.compute_FIM(method='sequential')
+    DoE_args["prior_FIM"] = FIM_prior
+
+    doe_obj = DesignOfExperiments(**DoE_args)
+    doe_obj.create_doe_model()
+
+    grey_box_object = FIMExternalGreyBox(
+        doe_object=doe_obj, objective_option=doe_obj.objective_option
+    )
+
+    return doe_obj, grey_box_object
+
+
 @unittest.skipIf(not ipopt_available, "The 'ipopt' command is not available")
 @unittest.skipIf(not numpy_available, "Numpy is not available")
+@unittest.skipIf(not scipy_available, "scipy is not available")
 class TestFIMExternalGreyBox(unittest.TestCase):
     # Test that we can properly
     # set the inputs for the
@@ -885,6 +919,157 @@ def test_evaluate_hessian_outputs_obj_lib_error(self):
         ):
             grey_box_object.evaluate_hessian_outputs()
 
+    # Test all versions of solving
+    # using grey box
+    def test_solve_D_optimality_log_determinant(self):
+        # Two locally optimal design points exist
+        # (time, optimal objective value)
+        # Here, the objective value is
+        # log-10(determinant) of the FIM
+        optimal_experimental_designs = [np.array([2.24, 4.33]), np.array([10.00, 4.35])]
+        objective_option = "determinant"
+        doe_object, grey_box_object = make_greybox_and_doe_objects_rooney_biegler(
+            objective_option=objective_option
+        )
+
+        # Set to use the grey box objective
+        doe_object.use_grey_box = True
+
+        # Solve the model
+        doe_object.run_doe()
+
+        optimal_time_val = doe_object.results["Experiment Design"][0]
+        optimal_obj_val = np.log10(np.exp(pyo.value(doe_object.model.objective)))
+
+        optimal_design_np_array = np.array([optimal_time_val, optimal_obj_val])
+
+        self.assertTrue(
+            np.all(
+                np.isclose(
+                    optimal_design_np_array, optimal_experimental_designs[0], 1e-2
+                )
+            )
+            or np.all(
+                np.isclose(
+                    optimal_design_np_array, optimal_experimental_designs[1], 1e-2
+                )
+            )
+        )
+
+    def test_solve_A_optimality_trace_of_inverse(self):
+        # Two locally optimal design points exist
+        # (time, optimal objective value)
+        # Here, the objective value is
+        # trace(inverse(FIM))
+        optimal_experimental_designs = [
+            np.array([1.94, 0.0295]),
+            np.array([9.9, 0.0366]),
+        ]
+        objective_option = "trace"
+        doe_object, grey_box_object = make_greybox_and_doe_objects_rooney_biegler(
+            objective_option=objective_option
+        )
+
+        # Set to use the grey box objective
+        doe_object.use_grey_box = True
+
+        # Solve the model
+        doe_object.run_doe()
+
+        optimal_time_val = doe_object.results["Experiment Design"][0]
+        optimal_obj_val = doe_object.model.objective()
+
+        optimal_design_np_array = np.array([optimal_time_val, optimal_obj_val])
+
+        self.assertTrue(
+            np.all(
+                np.isclose(
+                    optimal_design_np_array, optimal_experimental_designs[0], 1e-2
+                )
+            )
+            or np.all(
+                np.isclose(
+                    optimal_design_np_array, optimal_experimental_designs[1], 1e-2
+                )
+            )
+        )
+
+    def test_solve_E_optimality_minimum_eigenvalue(self):
+        # Two locally optimal design points exist
+        # (time, optimal objective value)
+        # Here, the objective value is
+        # minimum eigenvalue of the FIM
+        optimal_experimental_designs = [
+            np.array([1.92, 36.018]),
+            np.array([10.00, 28.349]),
+        ]
+        objective_option = "minimum_eigenvalue"
+        doe_object, grey_box_object = make_greybox_and_doe_objects_rooney_biegler(
+            objective_option=objective_option
+        )
+
+        # Set to use the grey box objective
+        doe_object.use_grey_box = True
+
+        # Solve the model
+        doe_object.run_doe()
+
+        optimal_time_val = doe_object.results["Experiment Design"][0]
+        optimal_obj_val = doe_object.model.objective()
+
+        optimal_design_np_array = np.array([optimal_time_val, optimal_obj_val])
+
+        self.assertTrue(
+            np.all(
+                np.isclose(
+                    optimal_design_np_array, optimal_experimental_designs[0], 1e-2
+                )
+            )
+            or np.all(
+                np.isclose(
+                    optimal_design_np_array, optimal_experimental_designs[1], 1e-2
+                )
+            )
+        )
+
+    def test_solve_ME_optimality_condition_number(self):
+        # Two locally optimal design points exist
+        # (time, optimal objective value)
+        # Here, the objective value is
+        # condition number of the FIM
+        optimal_experimental_designs = [
+            np.array([1.59, 15.22]),
+            np.array([10.00, 27.675]),
+        ]
+        objective_option = "condition_number"
+        doe_object, grey_box_object = make_greybox_and_doe_objects_rooney_biegler(
+            objective_option=objective_option
+        )
+
+        # Set to use the grey box objective
+        doe_object.use_grey_box = True
+
+        # Solve the model
+        doe_object.run_doe()
+
+        optimal_time_val = doe_object.results["Experiment Design"][0]
+        optimal_obj_val = doe_object.model.objective()
+
+        optimal_design_np_array = np.array([optimal_time_val, optimal_obj_val])
+
+        self.assertTrue(
+            np.all(
+                np.isclose(
+                    optimal_design_np_array, optimal_experimental_designs[0], 1e-2
+                )
+            )
+            or np.all(
+                np.isclose(
+                    optimal_design_np_array, optimal_experimental_designs[1], 1e-2
+                )
+            )
+        )
+
 
 if __name__ == "__main__":
     unittest.main()

From 4a2a7f4d0e898f549b1569a034f26a74a9acc057 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Fri, 23 May 2025 09:04:27 -0400
Subject: [PATCH 084/143] Removed incorrect skip?

Unsure if this needs kaug? I don't know why it would need kaug.
---
 pyomo/contrib/doe/tests/test_doe_solve.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/pyomo/contrib/doe/tests/test_doe_solve.py b/pyomo/contrib/doe/tests/test_doe_solve.py
index 0548e1beedc..32753e0ea7b 100644
--- a/pyomo/contrib/doe/tests/test_doe_solve.py
+++ b/pyomo/contrib/doe/tests/test_doe_solve.py
@@ -188,9 +188,7 @@ def test_reactor_fd_backward_solve(self):
         # Make sure FIM and Q.T @ sigma_inv @ Q are close (alternate definition of FIM)
         self.assertTrue(np.all(np.isclose(FIM, Q.T @ sigma_inv @ Q)))
 
-    @unittest.skipIf(
-        not k_aug_available.available(False), "The 'k_aug' command is not available"
-    )
+
     def test_reactor_obj_det_solve(self):
         fd_method = "central"
         obj_used = "determinant"

From e5d0757e0e6268d8b8f257a0170822c9e0cb1885 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Fri, 23 May 2025 09:11:20 -0400
Subject: [PATCH 085/143] Ran black

---
 pyomo/contrib/doe/tests/test_doe_solve.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/pyomo/contrib/doe/tests/test_doe_solve.py b/pyomo/contrib/doe/tests/test_doe_solve.py
index 32753e0ea7b..879ed139f58 100644
--- a/pyomo/contrib/doe/tests/test_doe_solve.py
+++ b/pyomo/contrib/doe/tests/test_doe_solve.py
@@ -188,7 +188,6 @@ def test_reactor_fd_backward_solve(self):
         # Make sure FIM and Q.T @ sigma_inv @ Q are close (alternate definition of FIM)
         self.assertTrue(np.all(np.isclose(FIM, Q.T @ sigma_inv @ Q)))
 
-
     def test_reactor_obj_det_solve(self):
         fd_method = "central"
         obj_used = "determinant"

From 9e7bfe2bc4d2b86180416df706ee3b9855b0251e Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Fri, 23 May 2025 09:19:29 -0400
Subject: [PATCH 086/143] Remove attribute error in DoE class

Error should always occur while creating the FIMExternalGreyBox block.
---
 pyomo/contrib/doe/doe.py | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index ea8c8f23446..eec20f3ae36 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -1445,10 +1445,9 @@ def FIM_egb_cons(m, p1, p2):
             model.objective = pyo.Objective(
                 expr=model.obj_cons.egb_fim_block.outputs["ME-opt"], sense=pyo.minimize
             )
-        else:
-            raise AttributeError(
-                "Objective option not recognized. Please contact the developers as you should not see this error."
-            )
+        # Else error not needed for spurious objective
+        # options as the error will always appear
+        # when creating the FIMExternalGreyBox block
 
     # Check to see if the model has all the required suffixes
     def check_model_labels(self, model=None):

From 2a788eb1389754e58417152ee013c70833301b86 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Fri, 23 May 2025 09:38:58 -0400
Subject: [PATCH 087/143] Cleaning up temporary solver changes

---
 pyomo/contrib/doe/doe.py | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index eec20f3ae36..55c52785b0c 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -208,10 +208,8 @@ def __init__(
         else:
             solver = pyo.SolverFactory("ipopt")
             solver.options["linear_solver"] = "ma57"
-            # solver.options["linear_solver"] = "MUMPS"
             solver.options["halt_on_ampl_error"] = "yes"
             solver.options["max_iter"] = 3000
-            solver.options["tol"] = 1e-5
             self.solver = solver
 
         self.tee = tee
@@ -221,9 +219,7 @@ def __init__(
             self.grey_box_solver = grey_box_solver
         else:
             grey_box_solver = pyo.SolverFactory("cyipopt")
-            # grey_box_solver.config.options['hessian_approximation'] = 'limited-memory'
             grey_box_solver.config.options["linear_solver"] = "ma57"
-            # grey_box_solver.config.options['max_iter'] = 1000
             grey_box_solver.config.options['tol'] = 1e-4
             grey_box_solver.config.options['mu_strategy'] = "monotone"
 

From 8295b38cb8049de595b284748bca3b54f4ac6a8e Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Fri, 23 May 2025 09:39:15 -0400
Subject: [PATCH 088/143] Add test for experiment=None in doe costructor

---
 pyomo/contrib/doe/tests/test_doe_errors.py | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/pyomo/contrib/doe/tests/test_doe_errors.py b/pyomo/contrib/doe/tests/test_doe_errors.py
index 4c9823a251d..e98c17136f0 100644
--- a/pyomo/contrib/doe/tests/test_doe_errors.py
+++ b/pyomo/contrib/doe/tests/test_doe_errors.py
@@ -60,6 +60,19 @@ def get_standard_args(experiment, fd_method, obj_used, flag):
 
 @unittest.skipIf(not numpy_available, "Numpy is not available")
 class TestReactorExampleErrors(unittest.TestCase):
+    def test_experiment_none_error(self):
+        fd_method = "central"
+        obj_used = "trace"
+        flag_val = 1  # Value for faulty model build mode - 1: No exp outputs
+
+        with self.assertRaisesRegex(
+            ValueError, "Experiment object must be provided to perform DoE."
+        ):
+            # Experiment provided as None
+            DoE_args = get_standard_args(None, fd_method, obj_used, flag_val)
+
+            doe_obj = DesignOfExperiments(**DoE_args)
+
     def test_reactor_check_no_get_labeled_model(self):
         fd_method = "central"
         obj_used = "trace"

From cb8843eb75f8fc1ced38726298a260a6c4616ec1 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Fri, 23 May 2025 09:39:34 -0400
Subject: [PATCH 089/143] Use the user-provided grey box solver

---
 pyomo/contrib/doe/tests/test_greybox.py | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index e8fe81c8d3e..98274e868e3 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -271,6 +271,15 @@ def make_greybox_and_doe_objects_rooney_biegler(objective_option):
     DoE_args = get_standard_args(experiment, fd_method, obj_used)
     DoE_args["use_grey_box_objective"] = True
 
+    # Make a custom grey box solver
+    grey_box_solver = SolverFactory("cyipopt")
+    grey_box_solver.config.options["linear_solver"] = "ma57"
+    grey_box_solver.config.options['tol'] = 1e-4
+    grey_box_solver.config.options['mu_strategy'] = "monotone"
+
+    # Add the grey box solver ot DoE_args
+    DoE_args["grey_box_solver"] = grey_box_solver
+
     data = [[1, 8.3], [7, 19.8]]
     FIM_prior = np.zeros((2, 2))
     # Calculate prior using existing experiments

From 41b620cee51b64e03331e3cc69143fd738ae333d Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Fri, 23 May 2025 09:42:52 -0400
Subject: [PATCH 090/143] Added scipy dependency

---
 pyomo/contrib/doe/tests/test_doe_build.py  | 2 ++
 pyomo/contrib/doe/tests/test_doe_errors.py | 2 ++
 pyomo/contrib/doe/tests/test_doe_solve.py  | 1 +
 3 files changed, 5 insertions(+)

diff --git a/pyomo/contrib/doe/tests/test_doe_build.py b/pyomo/contrib/doe/tests/test_doe_build.py
index 39615f47808..26260257d62 100644
--- a/pyomo/contrib/doe/tests/test_doe_build.py
+++ b/pyomo/contrib/doe/tests/test_doe_build.py
@@ -16,6 +16,7 @@
     numpy_available,
     pandas as pd,
     pandas_available,
+    scipy_available,
 )
 from pyomo.common.fileutils import this_file_dir
 import pyomo.common.unittest as unittest
@@ -119,6 +120,7 @@ def get_standard_args(experiment, fd_method, obj_used):
 
 @unittest.skipIf(not ipopt_available, "The 'ipopt' command is not available")
 @unittest.skipIf(not numpy_available, "Numpy is not available")
+@unittest.skipIf(not scipy_available, "scipy is not available")
 class TestReactorExampleBuild(unittest.TestCase):
     def test_reactor_fd_central_check_fd_eqns(self):
         fd_method = "central"
diff --git a/pyomo/contrib/doe/tests/test_doe_errors.py b/pyomo/contrib/doe/tests/test_doe_errors.py
index e98c17136f0..f3be67c5d75 100644
--- a/pyomo/contrib/doe/tests/test_doe_errors.py
+++ b/pyomo/contrib/doe/tests/test_doe_errors.py
@@ -16,6 +16,7 @@
     numpy_available,
     pandas as pd,
     pandas_available,
+    scipy_available,
 )
 from pyomo.common.fileutils import this_file_dir
 import pyomo.common.unittest as unittest
@@ -59,6 +60,7 @@ def get_standard_args(experiment, fd_method, obj_used, flag):
 
 
 @unittest.skipIf(not numpy_available, "Numpy is not available")
+@unittest.skipIf(not scipy_available, "scipy is not available")
 class TestReactorExampleErrors(unittest.TestCase):
     def test_experiment_none_error(self):
         fd_method = "central"
diff --git a/pyomo/contrib/doe/tests/test_doe_solve.py b/pyomo/contrib/doe/tests/test_doe_solve.py
index 879ed139f58..29324df8879 100644
--- a/pyomo/contrib/doe/tests/test_doe_solve.py
+++ b/pyomo/contrib/doe/tests/test_doe_solve.py
@@ -120,6 +120,7 @@ def get_standard_args(experiment, fd_method, obj_used):
 
 @unittest.skipIf(not ipopt_available, "The 'ipopt' command is not available")
 @unittest.skipIf(not numpy_available, "Numpy is not available")
+@unittest.skipIf(not scipy_available, "scipy is not available")
 class TestReactorExampleSolving(unittest.TestCase):
     def test_reactor_fd_central_solve(self):
         fd_method = "central"

From ee6ce8c843dd58d388108e616081b9342d3ce753 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Fri, 23 May 2025 09:44:32 -0400
Subject: [PATCH 091/143] Fixed typo

---
 pyomo/contrib/doe/tests/test_greybox.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 98274e868e3..9b3e5d5c403 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -277,7 +277,7 @@ def make_greybox_and_doe_objects_rooney_biegler(objective_option):
     grey_box_solver.config.options['tol'] = 1e-4
     grey_box_solver.config.options['mu_strategy'] = "monotone"
 
-    # Add the grey box solver ot DoE_args
+    # Add the grey box solver to DoE_args
     DoE_args["grey_box_solver"] = grey_box_solver
 
     data = [[1, 8.3], [7, 19.8]]

From 48ef6a8d39b9d516a1854c0a81fc9b7a2bba3d2b Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Fri, 23 May 2025 09:50:21 -0400
Subject: [PATCH 092/143] Add conditional for FIMExternalGreyBox import

---
 pyomo/contrib/doe/tests/test_greybox.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 9b3e5d5c403..a4f21d1a94b 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -23,7 +23,9 @@
 from pyomo.common.fileutils import this_file_dir
 import pyomo.common.unittest as unittest
 
-from pyomo.contrib.doe import DesignOfExperiments, FIMExternalGreyBox
+if scipy_available:
+    from pyomo.contrib.doe import DesignOfExperiments, FIMExternalGreyBox
+
 from pyomo.contrib.doe.examples.reactor_example import (
     ReactorExperiment as FullReactorExperiment,
 )

From 17369c4043d44e6a8449910f5ddbbed4346e4485 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Fri, 23 May 2025 10:57:06 -0400
Subject: [PATCH 093/143] Add scipy available flag

---
 pyomo/contrib/doe/tests/test_doe_build.py  | 3 ++-
 pyomo/contrib/doe/tests/test_doe_errors.py | 3 ++-
 pyomo/contrib/doe/tests/test_doe_solve.py  | 3 ++-
 3 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/pyomo/contrib/doe/tests/test_doe_build.py b/pyomo/contrib/doe/tests/test_doe_build.py
index 26260257d62..e7cbab5ec9a 100644
--- a/pyomo/contrib/doe/tests/test_doe_build.py
+++ b/pyomo/contrib/doe/tests/test_doe_build.py
@@ -21,7 +21,8 @@
 from pyomo.common.fileutils import this_file_dir
 import pyomo.common.unittest as unittest
 
-from pyomo.contrib.doe import DesignOfExperiments
+if scipy_available:
+    from pyomo.contrib.doe import DesignOfExperiments
 from pyomo.contrib.doe.examples.reactor_example import (
     ReactorExperiment as FullReactorExperiment,
 )
diff --git a/pyomo/contrib/doe/tests/test_doe_errors.py b/pyomo/contrib/doe/tests/test_doe_errors.py
index f3be67c5d75..d1650e4b55c 100644
--- a/pyomo/contrib/doe/tests/test_doe_errors.py
+++ b/pyomo/contrib/doe/tests/test_doe_errors.py
@@ -21,7 +21,8 @@
 from pyomo.common.fileutils import this_file_dir
 import pyomo.common.unittest as unittest
 
-from pyomo.contrib.doe import DesignOfExperiments
+if scipy_available:
+    from pyomo.contrib.doe import DesignOfExperiments
 from pyomo.contrib.doe.tests.experiment_class_example_flags import (
     BadExperiment,
     FullReactorExperiment,
diff --git a/pyomo/contrib/doe/tests/test_doe_solve.py b/pyomo/contrib/doe/tests/test_doe_solve.py
index 29324df8879..d7a43dddf00 100644
--- a/pyomo/contrib/doe/tests/test_doe_solve.py
+++ b/pyomo/contrib/doe/tests/test_doe_solve.py
@@ -22,7 +22,8 @@
 from pyomo.common.fileutils import this_file_dir
 import pyomo.common.unittest as unittest
 
-from pyomo.contrib.doe import DesignOfExperiments
+if scipy_available:
+    from pyomo.contrib.doe import DesignOfExperiments
 from pyomo.contrib.doe.examples.reactor_example import (
     ReactorExperiment as FullReactorExperiment,
 )

From bf6fa53d756c0d7182baa3f6778fc290a5fca8f2 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Fri, 23 May 2025 10:57:14 -0400
Subject: [PATCH 094/143] Add cyipopt available flag

---
 pyomo/contrib/doe/tests/test_greybox.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index a4f21d1a94b..fe00e7b2d90 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -36,6 +36,7 @@
 from pyomo.opt import SolverFactory
 
 ipopt_available = SolverFactory("ipopt").available()
+cyipopt_available = SolverFactory("cyipopt").available()
 
 currdir = this_file_dir()
 file_path = os.path.join(currdir, "..", "examples", "result.json")
@@ -309,6 +310,7 @@ def make_greybox_and_doe_objects_rooney_biegler(objective_option):
 @unittest.skipIf(not ipopt_available, "The 'ipopt' command is not available")
 @unittest.skipIf(not numpy_available, "Numpy is not available")
 @unittest.skipIf(not scipy_available, "scipy is not available")
+@unittest.skipIf(not cyipopt_available, "'cyipopt' is not available")
 class TestFIMExternalGreyBox(unittest.TestCase):
     # Test that we can properly
     # set the inputs for the

From f6bc33130d6f479d088c03c9804b3039cfb51165 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Fri, 23 May 2025 11:29:55 -0400
Subject: [PATCH 095/143] Updated 'inv' to 'pinv' function to be consistent

This was for the objective value piece for trace.
---
 pyomo/contrib/doe/grey_box_utilities.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index f8795a48d12..e8e14a59bfb 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -172,7 +172,7 @@ def evaluate_outputs(self):
         from pyomo.contrib.doe import ObjectiveLib
 
         if self.objective_option == ObjectiveLib.trace:
-            obj_value = np.trace(np.linalg.inv(M))
+            obj_value = np.trace(np.linalg.pinv(M))
         elif self.objective_option == ObjectiveLib.determinant:
             (sign, logdet) = np.linalg.slogdet(M)
             obj_value = logdet

From ea353618ff956367a51d3119681e75d076aea2e9 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Fri, 23 May 2025 11:30:50 -0400
Subject: [PATCH 096/143] Delete
 pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py

---
 .../doe/examples/grey_box_D_opt_comparison.py | 197 ------------------
 1 file changed, 197 deletions(-)
 delete mode 100644 pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py

diff --git a/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py b/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
deleted file mode 100644
index 61027e10dd8..00000000000
--- a/pyomo/contrib/doe/examples/grey_box_D_opt_comparison.py
+++ /dev/null
@@ -1,197 +0,0 @@
-#  ___________________________________________________________________________
-#
-#  Pyomo: Python Optimization Modeling Objects
-#  Copyright (c) 2008-2024
-#  National Technology and Engineering Solutions of Sandia, LLC
-#  Under the terms of Contract DE-NA0003525 with National Technology and
-#  Engineering Solutions of Sandia, LLC, the U.S. Government retains certain
-#  rights in this software.
-#  This software is distributed under the 3-clause BSD License.
-#  ___________________________________________________________________________
-from pyomo.common.dependencies import numpy as np
-
-from pyomo.contrib.doe.examples.reactor_experiment import ReactorExperiment
-from pyomo.contrib.doe import DesignOfExperiments
-
-import pyomo.environ as pyo
-
-import json
-import logging
-from pathlib import Path
-
-
-# Seeing if D-optimal experiment matches for both the
-# greybox objective and the algebraic objective
-def compare_reactor_doe():
-    # Read in file
-    DATA_DIR = Path(__file__).parent
-    file_path = DATA_DIR / "result.json"
-
-    with open(file_path) as f:
-        data_ex = json.load(f)
-
-    # Put temperature control time points into correct format for reactor experiment
-    data_ex["control_points"] = {
-        float(k): v for k, v in data_ex["control_points"].items()
-    }
-
-    # Create a ReactorExperiment object; data and discretization information are part
-    # of the constructor of this object
-    experiment = ReactorExperiment(data=data_ex, nfe=10, ncp=3)
-
-    # Use a central difference, with step size 1e-3
-    fd_formula = "central"
-    step_size = 1e-3
-
-    # Use the determinant objective with scaled sensitivity matrix
-    objective_option = "determinant"
-    scale_nominal_param_value = True
-
-    # solver = pyo.SolverFactory("ipopt")
-    # solver.options["linear_solver"] = "mumps"
-    # Create the DesignOfExperiments object
-    # We will not be passing any prior information in this example
-    # and allow the experiment object and the DesignOfExperiments
-    # call of ``run_doe`` perform model initialization.
-    doe_obj = DesignOfExperiments(
-        experiment,
-        fd_formula=fd_formula,
-        step=step_size,
-        objective_option=objective_option,
-        scale_constant_value=1,
-        scale_nominal_param_value=scale_nominal_param_value,
-        prior_FIM=None,
-        jac_initial=None,
-        fim_initial=None,
-        L_diagonal_lower_bound=1e-7,
-        solver=None,
-        tee=True,
-        get_labeled_model_args=None,
-        # logger_level=logging.ERROR,
-        _Cholesky_option=True,
-        _only_compute_fim_lower=True,
-    )
-
-    prior_FIM = doe_obj.compute_FIM(method='sequential')
-    doe_obj.prior_FIM = prior_FIM
-
-    # Begin optimal DoE
-    ####################
-    doe_obj.run_doe()
-
-    # Print out a results summary
-    print("Optimal experiment values: ")
-    print(
-        "\tInitial concentration: {:.2f}".format(
-            doe_obj.results["Experiment Design"][0]
-        )
-    )
-    # print(
-    #     ("\tTemperature values: [" + "{:.2f}, " * 8 + "{:.2f}]").format(
-    #         *doe_obj.results["Experiment Design"][1:]
-    #     )
-    # )
-    print("FIM at optimal design:\n {}".format(np.array(doe_obj.results["FIM"])))
-    print(
-        "Objective value at optimal design: {:.2f}".format(
-            pyo.value(doe_obj.model.objective)
-        )
-    )
-
-    print(doe_obj.results["Experiment Design Names"])
-
-    ###################
-    # End optimal DoE
-
-    # Begin optimal grey box DoE
-    ############################
-    doe_obj_grey_box = DesignOfExperiments(
-        experiment,
-        fd_formula=fd_formula,
-        step=step_size,
-        objective_option=objective_option,
-        use_grey_box_objective=True,  # New object with grey box set to True
-        scale_constant_value=1,
-        scale_nominal_param_value=scale_nominal_param_value,
-        prior_FIM=prior_FIM,
-        jac_initial=None,
-        fim_initial=None,
-        L_diagonal_lower_bound=1e-7,
-        solver=None,
-        tee=True,
-        get_labeled_model_args=None,
-        # logger_level=logging.ERROR,
-        _Cholesky_option=True,
-        _only_compute_fim_lower=True,
-    )
-
-    doe_obj_grey_box.run_doe()
-    # Print out a results summary
-    print("Optimal experiment values with grey-box: ")
-    print(
-        "\tInitial concentration: {:.2f}".format(
-            doe_obj_grey_box.results["Experiment Design"][0]
-        )
-    )
-    # print(
-    #     ("\tTemperature values: [" + "{:.2f}, " * 8 + "{:.2f}]").format(
-    #         *doe_obj_grey_box.results["Experiment Design"][1:]
-    #     )
-    # )
-    print(
-        ("\tTemperature values: [" "{:.2f}]").format(
-            doe_obj_grey_box.results["Experiment Design"][1]
-        )
-    )
-    print(
-        "FIM at optimal design with grey-box:\n {}".format(
-            np.array(doe_obj_grey_box.results["FIM"])
-        )
-    )
-    print(
-        "Objective value at optimal design with grey-box: {:.2f}".format(
-            pyo.value(doe_obj_grey_box.model.objective)
-        )
-    )
-    print(
-        "Raw logdet: {:.2f}".format(
-            np.log10(np.linalg.det(np.array(doe_obj_grey_box.results["FIM"])))
-        )
-    )
-
-    print(doe_obj_grey_box.results["Experiment Design Names"])
-
-    print()
-
-    # Print out a results summary
-    print("Optimal experiment values: ")
-    print(
-        "\tInitial concentration: {:.2f}".format(
-            doe_obj.results["Experiment Design"][0]
-        )
-    )
-    # print(
-    #     ("\tTemperature values: [" + "{:.2f}, " * 8 + "{:.2f}]").format(
-    #         *doe_obj.results["Experiment Design"][1:]
-    #     )
-    # )
-    print(
-        ("\tTemperature values: [" "{:.2f}]").format(
-            doe_obj.results["Experiment Design"][1]
-        )
-    )
-    print("FIM at optimal design:\n {}".format(np.array(doe_obj.results["FIM"])))
-    print(
-        "Objective value at optimal design: {:.2f}".format(
-            pyo.value(doe_obj.model.objective)
-        )
-    )
-
-    print(doe_obj.results["Experiment Design Names"])
-
-    print(dir(doe_obj_grey_box.model.obj_cons.egb_fim_block))
-    doe_obj_grey_box.model.obj_cons.egb_fim_block._input_names_set.pprint()
-
-
-if __name__ == "__main__":
-    compare_reactor_doe()

From ea1cadb3a1045001adc9cda528fd62d18453465c Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Fri, 23 May 2025 11:31:01 -0400
Subject: [PATCH 097/143] Delete pyomo/contrib/doe/examples/grey_box_E_opt.py

---
 pyomo/contrib/doe/examples/grey_box_E_opt.py | 142 -------------------
 1 file changed, 142 deletions(-)
 delete mode 100644 pyomo/contrib/doe/examples/grey_box_E_opt.py

diff --git a/pyomo/contrib/doe/examples/grey_box_E_opt.py b/pyomo/contrib/doe/examples/grey_box_E_opt.py
deleted file mode 100644
index bdb0f6f6cd1..00000000000
--- a/pyomo/contrib/doe/examples/grey_box_E_opt.py
+++ /dev/null
@@ -1,142 +0,0 @@
-#  ___________________________________________________________________________
-#
-#  Pyomo: Python Optimization Modeling Objects
-#  Copyright (c) 2008-2024
-#  National Technology and Engineering Solutions of Sandia, LLC
-#  Under the terms of Contract DE-NA0003525 with National Technology and
-#  Engineering Solutions of Sandia, LLC, the U.S. Government retains certain
-#  rights in this software.
-#  This software is distributed under the 3-clause BSD License.
-#  ___________________________________________________________________________
-from pyomo.common.dependencies import numpy as np
-
-from pyomo.contrib.doe.examples.reactor_experiment import ReactorExperiment
-from pyomo.contrib.doe import DesignOfExperiments
-
-import pyomo.environ as pyo
-
-import json
-import logging
-from pathlib import Path
-
-
-# Seeing if D-optimal experiment matches for both the
-# greybox objective and the algebraic objective
-def compare_reactor_doe():
-    # Read in file
-    DATA_DIR = Path(__file__).parent
-    file_path = DATA_DIR / "result.json"
-
-    with open(file_path) as f:
-        data_ex = json.load(f)
-
-    # Put temperature control time points into correct format for reactor experiment
-    data_ex["control_points"] = {
-        float(k): v for k, v in data_ex["control_points"].items()
-    }
-
-    # Create a ReactorExperiment object; data and discretization information are part
-    # of the constructor of this object
-    experiment = ReactorExperiment(data=data_ex, nfe=10, ncp=3)
-
-    # Use a central difference, with step size 1e-3
-    fd_formula = "central"
-    step_size = 1e-3
-
-    # Use the determinant objective with scaled sensitivity matrix
-    objective_option = "minimum_eigenvalue"
-    scale_nominal_param_value = True
-
-    solver = pyo.SolverFactory("ipopt")
-    # solver.options["linear_solver"] = "mumps"
-
-    # DoE object to compute FIM prior
-    # doe_obj = DesignOfExperiments(
-    #     experiment,
-    #     fd_formula=fd_formula,
-    #     step=step_size,
-    #     objective_option=objective_option,
-    #     use_grey_box_objective=True,  # New object with grey box set to True
-    #     scale_constant_value=1,
-    #     scale_nominal_param_value=scale_nominal_param_value,
-    #     prior_FIM=None,
-    #     jac_initial=None,
-    #     fim_initial=None,
-    #     L_diagonal_lower_bound=1e-7,
-    #     solver=solver,
-    #     tee=True,
-    #     get_labeled_model_args=None,
-    #     # logger_level=logging.ERROR,
-    #     _Cholesky_option=True,
-    #     _only_compute_fim_lower=True,
-    # )
-
-    # prior_FIM = doe_obj.compute_FIM(method="sequential")
-    prior_FIM = None
-
-    # Begin optimal grey box DoE
-    ############################
-    doe_obj_grey_box = DesignOfExperiments(
-        experiment,
-        fd_formula=fd_formula,
-        step=step_size,
-        objective_option=objective_option,
-        use_grey_box_objective=True,  # New object with grey box set to True
-        scale_constant_value=1,
-        scale_nominal_param_value=scale_nominal_param_value,
-        prior_FIM=prior_FIM,
-        jac_initial=None,
-        fim_initial=None,
-        L_diagonal_lower_bound=1e-7,
-        solver=solver,
-        tee=True,
-        get_labeled_model_args=None,
-        # logger_level=logging.ERROR,
-        _Cholesky_option=True,
-        _only_compute_fim_lower=True,
-    )
-
-    doe_obj_grey_box.run_doe()
-    # Print out a results summary
-    print("Optimal experiment values with grey-box: ")
-    print(
-        "\tInitial concentration: {:.2f}".format(
-            doe_obj_grey_box.results["Experiment Design"][0]
-        )
-    )
-    print(
-        ("\tTemperature values: [{:.2f}]").format(
-            doe_obj_grey_box.results["Experiment Design"][1]
-        )
-    )
-    # print(
-    #     ("\tTemperature values: [" + "{:.2f}, " * 8 + "{:.2f}]").format(
-    #         *doe_obj_grey_box.results["Experiment Design"][1:]
-    #     )
-    # )
-    print(
-        "FIM at optimal design with grey-box:\n {}".format(
-            np.array(doe_obj_grey_box.results["FIM"])
-        )
-    )
-    print(
-        "Objective value at optimal design with grey-box: {:.2f}".format(
-            pyo.value(doe_obj_grey_box.model.objective)
-        )
-    )
-    print(
-        "E-opt at optimal design with grey-box: {:.2f}".format(
-            pyo.value(doe_obj_grey_box.results["log10 E-opt"])
-        )
-    )
-    print(
-        "Raw logdet: {:.2f}".format(
-            np.log10(np.linalg.det(np.array(doe_obj_grey_box.results["FIM"])))
-        )
-    )
-
-    print(doe_obj_grey_box.results["Experiment Design Names"])
-
-
-if __name__ == "__main__":
-    compare_reactor_doe()

From f1f9af2745556991238d0744bbbe76a2c4035f2d Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Fri, 23 May 2025 11:31:13 -0400
Subject: [PATCH 098/143] Delete pyomo/contrib/doe/examples/grey_box_ME_opt.py

---
 pyomo/contrib/doe/examples/grey_box_ME_opt.py | 140 ------------------
 1 file changed, 140 deletions(-)
 delete mode 100644 pyomo/contrib/doe/examples/grey_box_ME_opt.py

diff --git a/pyomo/contrib/doe/examples/grey_box_ME_opt.py b/pyomo/contrib/doe/examples/grey_box_ME_opt.py
deleted file mode 100644
index cca0c0a09dc..00000000000
--- a/pyomo/contrib/doe/examples/grey_box_ME_opt.py
+++ /dev/null
@@ -1,140 +0,0 @@
-#  ___________________________________________________________________________
-#
-#  Pyomo: Python Optimization Modeling Objects
-#  Copyright (c) 2008-2024
-#  National Technology and Engineering Solutions of Sandia, LLC
-#  Under the terms of Contract DE-NA0003525 with National Technology and
-#  Engineering Solutions of Sandia, LLC, the U.S. Government retains certain
-#  rights in this software.
-#  This software is distributed under the 3-clause BSD License.
-#  ___________________________________________________________________________
-from pyomo.common.dependencies import numpy as np
-
-from pyomo.contrib.doe.examples.reactor_experiment import ReactorExperiment
-from pyomo.contrib.doe import DesignOfExperiments
-
-import pyomo.environ as pyo
-
-import json
-import logging
-from pathlib import Path
-
-
-# Seeing if D-optimal experiment matches for both the
-# greybox objective and the algebraic objective
-def compare_reactor_doe():
-    # Read in file
-    DATA_DIR = Path(__file__).parent
-    file_path = DATA_DIR / "result.json"
-
-    with open(file_path) as f:
-        data_ex = json.load(f)
-
-    # Put temperature control time points into correct format for reactor experiment
-    data_ex["control_points"] = {
-        float(k): v for k, v in data_ex["control_points"].items()
-    }
-
-    # Create a ReactorExperiment object; data and discretization information are part
-    # of the constructor of this object
-    experiment = ReactorExperiment(data=data_ex, nfe=10, ncp=3)
-
-    # Use a central difference, with step size 1e-3
-    fd_formula = "central"
-    step_size = 1e-3
-
-    # Use the determinant objective with scaled sensitivity matrix
-    objective_option = "condition_number"
-    scale_nominal_param_value = True
-
-    solver = pyo.SolverFactory("ipopt")
-    # solver.options["linear_solver"] = "mumps"
-
-    # DoE object to compute FIM prior
-    doe_obj = DesignOfExperiments(
-        experiment,
-        fd_formula=fd_formula,
-        step=step_size,
-        objective_option=objective_option,
-        use_grey_box_objective=True,  # New object with grey box set to True
-        scale_constant_value=1,
-        scale_nominal_param_value=scale_nominal_param_value,
-        prior_FIM=None,
-        jac_initial=None,
-        fim_initial=None,
-        L_diagonal_lower_bound=1e-7,
-        solver=solver,
-        tee=True,
-        get_labeled_model_args=None,
-        # logger_level=logging.ERROR,
-        _Cholesky_option=True,
-        _only_compute_fim_lower=True,
-    )
-
-    prior_FIM = doe_obj.compute_FIM(method="sequential")
-    # prior_FIM = None
-
-    # Begin optimal grey box DoE
-    ############################
-    doe_obj_grey_box = DesignOfExperiments(
-        experiment,
-        fd_formula=fd_formula,
-        step=step_size,
-        objective_option=objective_option,
-        use_grey_box_objective=True,  # New object with grey box set to True
-        scale_constant_value=1,
-        scale_nominal_param_value=scale_nominal_param_value,
-        prior_FIM=None,
-        jac_initial=None,
-        fim_initial=None,
-        L_diagonal_lower_bound=1e-7,
-        solver=solver,
-        tee=True,
-        get_labeled_model_args=None,
-        # logger_level=logging.ERROR,
-        _Cholesky_option=True,
-        _only_compute_fim_lower=True,
-    )
-
-    doe_obj_grey_box.run_doe()
-    # Print out a results summary
-    print("Optimal experiment values with grey-box: ")
-    print(
-        "\tInitial concentration: {:.2f}".format(
-            doe_obj_grey_box.results["Experiment Design"][0]
-        )
-    )
-    print(
-        ("\tTemperature values: [{:.2f}]").format(
-            doe_obj_grey_box.results["Experiment Design"][1]
-        )
-    )
-    # print(
-    #     ("\tTemperature values: [" + "{:.2f}, " * 8 + "{:.2f}]").format(
-    #         *doe_obj_grey_box.results["Experiment Design"][1:]
-    #     )
-    # )
-    print(
-        "FIM at optimal design with grey-box:\n {}".format(
-            np.array(doe_obj_grey_box.results["FIM"])
-        )
-    )
-    print(
-        "Objective value at optimal design with grey-box: {:.2f}".format(
-            pyo.value(doe_obj_grey_box.model.objective)
-        )
-    )
-    print(
-        "Raw logdet: {:.2f}".format(
-            np.log10(np.linalg.det(np.array(doe_obj_grey_box.results["FIM"])))
-        )
-    )
-    print("Eigenvalues")
-    eig, _ = np.linalg.eig(np.array(doe_obj_grey_box.results["FIM"]))
-    print(np.max(eig), np.min(eig))
-
-    print(doe_obj_grey_box.results["Experiment Design Names"])
-
-
-if __name__ == "__main__":
-    compare_reactor_doe()

From f4e225e0c968a51441d9a9a72fa44490a3666a60 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Fri, 23 May 2025 11:31:22 -0400
Subject: [PATCH 099/143] Delete
 pyomo/contrib/doe/examples/grey_box_test_hessian.py

---
 .../doe/examples/grey_box_test_hessian.py     | 106 ------------------
 1 file changed, 106 deletions(-)
 delete mode 100644 pyomo/contrib/doe/examples/grey_box_test_hessian.py

diff --git a/pyomo/contrib/doe/examples/grey_box_test_hessian.py b/pyomo/contrib/doe/examples/grey_box_test_hessian.py
deleted file mode 100644
index ff1f5d5f2ee..00000000000
--- a/pyomo/contrib/doe/examples/grey_box_test_hessian.py
+++ /dev/null
@@ -1,106 +0,0 @@
-#  ___________________________________________________________________________
-#
-#  Pyomo: Python Optimization Modeling Objects
-#  Copyright (c) 2008-2024
-#  National Technology and Engineering Solutions of Sandia, LLC
-#  Under the terms of Contract DE-NA0003525 with National Technology and
-#  Engineering Solutions of Sandia, LLC, the U.S. Government retains certain
-#  rights in this software.
-#  This software is distributed under the 3-clause BSD License.
-#  ___________________________________________________________________________
-from pyomo.common.dependencies import numpy as np
-
-from pyomo.contrib.doe.examples.reactor_experiment import ReactorExperiment
-from pyomo.contrib.doe import DesignOfExperiments
-
-import pyomo.environ as pyo
-
-import json
-import logging
-from pathlib import Path
-
-from pyomo.contrib.doe import FIMExternalGreyBox
-
-
-# Seeing if D-optimal experiment matches for both the
-# greybox objective and the algebraic objective
-def compare_reactor_doe():
-    # Read in file
-    DATA_DIR = Path(__file__).parent
-    file_path = DATA_DIR / "result.json"
-
-    with open(file_path) as f:
-        data_ex = json.load(f)
-
-    # Put temperature control time points into correct format for reactor experiment
-    data_ex["control_points"] = {
-        float(k): v for k, v in data_ex["control_points"].items()
-    }
-
-    # Create a ReactorExperiment object; data and discretization information are part
-    # of the constructor of this object
-    experiment = ReactorExperiment(data=data_ex, nfe=10, ncp=3)
-
-    # Use a central difference, with step size 1e-3
-    fd_formula = "central"
-    step_size = 1e-3
-
-    # Use the determinant objective with scaled sensitivity matrix
-    objective_option = "determinant"
-    scale_nominal_param_value = True
-
-    # solver = pyo.SolverFactory("ipopt")
-    # solver.options["linear_solver"] = "mumps"
-
-    # DoE object to compute FIM prior
-    # doe_obj = DesignOfExperiments(
-    #     experiment,
-    #     fd_formula=fd_formula,
-    #     step=step_size,
-    #     objective_option=objective_option,
-    #     use_grey_box_objective=True,  # New object with grey box set to True
-    #     scale_constant_value=1,
-    #     scale_nominal_param_value=scale_nominal_param_value,
-    #     prior_FIM=None,
-    #     jac_initial=None,
-    #     fim_initial=None,
-    #     L_diagonal_lower_bound=1e-7,
-    #     solver=solver,
-    #     tee=True,
-    #     get_labeled_model_args=None,
-    #     # logger_level=logging.ERROR,
-    #     _Cholesky_option=True,
-    #     _only_compute_fim_lower=True,
-    # )
-
-    # prior_FIM = doe_obj.compute_FIM(method="sequential")
-    prior_FIM = None
-
-    # Begin optimal grey box DoE
-    ############################
-    doe_obj = DesignOfExperiments(
-        experiment,
-        fd_formula=fd_formula,
-        step=step_size,
-        objective_option=objective_option,
-        scale_constant_value=1,
-        scale_nominal_param_value=scale_nominal_param_value,
-        prior_FIM=None,
-        jac_initial=None,
-        fim_initial=None,
-        L_diagonal_lower_bound=1e-7,
-        solver=None,
-        tee=True,
-        get_labeled_model_args=None,
-        _Cholesky_option=True,
-        _only_compute_fim_lower=True,
-    )
-
-    doe_obj.run_doe()
-
-    grey_box_check = FIMExternalGreyBox(doe_object=doe_obj)
-    return grey_box_check, doe_obj
-
-
-if __name__ == "__main__":
-    compare_reactor_doe()

From 793c6be88b10035f19c529f3954b1f456d0a1e23 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Fri, 23 May 2025 12:10:45 -0400
Subject: [PATCH 100/143] Trying to loosen isclose tolerance for cyipopt

---
 pyomo/contrib/doe/tests/test_greybox.py | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index fe00e7b2d90..88d3e196acd 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -959,12 +959,12 @@ def test_solve_D_optimality_log_determinant(self):
         self.assertTrue(
             np.all(
                 np.isclose(
-                    optimal_design_np_array, optimal_experimental_designs[0], 1e-2
+                    optimal_design_np_array, optimal_experimental_designs[0], 1e-1
                 )
             )
             or np.all(
                 np.isclose(
-                    optimal_design_np_array, optimal_experimental_designs[1], 1e-2
+                    optimal_design_np_array, optimal_experimental_designs[1], 1e-1
                 )
             )
         )
@@ -997,12 +997,12 @@ def test_solve_A_optimality_trace_of_inverse(self):
         self.assertTrue(
             np.all(
                 np.isclose(
-                    optimal_design_np_array, optimal_experimental_designs[0], 1e-2
+                    optimal_design_np_array, optimal_experimental_designs[0], 1e-1
                 )
             )
             or np.all(
                 np.isclose(
-                    optimal_design_np_array, optimal_experimental_designs[1], 1e-2
+                    optimal_design_np_array, optimal_experimental_designs[1], 1e-1
                 )
             )
         )
@@ -1035,12 +1035,12 @@ def test_solve_E_optimality_minimum_eigenvalue(self):
         self.assertTrue(
             np.all(
                 np.isclose(
-                    optimal_design_np_array, optimal_experimental_designs[0], 1e-2
+                    optimal_design_np_array, optimal_experimental_designs[0], 1e-1
                 )
             )
             or np.all(
                 np.isclose(
-                    optimal_design_np_array, optimal_experimental_designs[1], 1e-2
+                    optimal_design_np_array, optimal_experimental_designs[1], 1e-1
                 )
             )
         )
@@ -1073,12 +1073,12 @@ def test_solve_ME_optimality_condition_number(self):
         self.assertTrue(
             np.all(
                 np.isclose(
-                    optimal_design_np_array, optimal_experimental_designs[0], 1e-2
+                    optimal_design_np_array, optimal_experimental_designs[0], 1e-1
                 )
             )
             or np.all(
                 np.isclose(
-                    optimal_design_np_array, optimal_experimental_designs[1], 1e-2
+                    optimal_design_np_array, optimal_experimental_designs[1], 1e-1
                 )
             )
         )

From 7f15294188a5e76200c33bd2ead3821171f3744c Mon Sep 17 00:00:00 2001
From: djalky <dlakes94@gmail.com>
Date: Tue, 27 May 2025 10:43:02 -0400
Subject: [PATCH 101/143] Remove matplotlib dependency for example file.

---
 pyomo/contrib/doe/examples/rooney_biegler_example.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/pyomo/contrib/doe/examples/rooney_biegler_example.py b/pyomo/contrib/doe/examples/rooney_biegler_example.py
index ebc37a14d4e..954f0eed435 100644
--- a/pyomo/contrib/doe/examples/rooney_biegler_example.py
+++ b/pyomo/contrib/doe/examples/rooney_biegler_example.py
@@ -22,7 +22,6 @@
 
 import pyomo.environ as pyo
 
-import matplotlib.pyplot as plt
 import json
 import sys
 

From bd9dfb011e29fd4718f0e3a8e4f76e0ab5e8e0ab Mon Sep 17 00:00:00 2001
From: djalky <dlakes94@gmail.com>
Date: Tue, 27 May 2025 14:55:53 -0400
Subject: [PATCH 102/143] Updating import statements to avoid scipy import

---
 pyomo/contrib/doe/grey_box_utilities.py    | 11 +++++++++--
 pyomo/contrib/doe/tests/test_doe_build.py  |  6 +++---
 pyomo/contrib/doe/tests/test_doe_errors.py |  8 ++++----
 pyomo/contrib/doe/tests/test_doe_solve.py  | 12 ++++++------
 pyomo/contrib/doe/tests/test_greybox.py    | 11 ++++++-----
 5 files changed, 28 insertions(+), 20 deletions(-)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index e8e14a59bfb..57cf71c687a 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -25,12 +25,19 @@
 #  publicly, and to permit other to do so.
 #  ___________________________________________________________________________
 
+from pyomo.common.dependencies import numpy as np, scipy_available
+
 from enum import Enum
 import itertools
 import logging
-from scipy.sparse import coo_matrix
 
-from pyomo.common.dependencies import numpy as np
+if not scipy_available:
+    raise ImportError(
+        "The scipy module is not available. "
+        "You need scipy to utilize the grey "
+        "box functionalities in Pyomo.DoE."
+    )
+from scipy.sparse import coo_matrix
 
 from pyomo.contrib.pynumero.interfaces.external_grey_box import ExternalGreyBoxModel
 
diff --git a/pyomo/contrib/doe/tests/test_doe_build.py b/pyomo/contrib/doe/tests/test_doe_build.py
index e7cbab5ec9a..2941a1441c0 100644
--- a/pyomo/contrib/doe/tests/test_doe_build.py
+++ b/pyomo/contrib/doe/tests/test_doe_build.py
@@ -23,9 +23,9 @@
 
 if scipy_available:
     from pyomo.contrib.doe import DesignOfExperiments
-from pyomo.contrib.doe.examples.reactor_example import (
-    ReactorExperiment as FullReactorExperiment,
-)
+    from pyomo.contrib.doe.examples.reactor_example import (
+        ReactorExperiment as FullReactorExperiment,
+    )
 
 import pyomo.environ as pyo
 
diff --git a/pyomo/contrib/doe/tests/test_doe_errors.py b/pyomo/contrib/doe/tests/test_doe_errors.py
index d1650e4b55c..d646c55006f 100644
--- a/pyomo/contrib/doe/tests/test_doe_errors.py
+++ b/pyomo/contrib/doe/tests/test_doe_errors.py
@@ -23,10 +23,10 @@
 
 if scipy_available:
     from pyomo.contrib.doe import DesignOfExperiments
-from pyomo.contrib.doe.tests.experiment_class_example_flags import (
-    BadExperiment,
-    FullReactorExperiment,
-)
+    from pyomo.contrib.doe.tests.experiment_class_example_flags import (
+        BadExperiment,
+        FullReactorExperiment,
+    )
 
 from pyomo.opt import SolverFactory
 
diff --git a/pyomo/contrib/doe/tests/test_doe_solve.py b/pyomo/contrib/doe/tests/test_doe_solve.py
index d7a43dddf00..9b8bbfe56ff 100644
--- a/pyomo/contrib/doe/tests/test_doe_solve.py
+++ b/pyomo/contrib/doe/tests/test_doe_solve.py
@@ -24,12 +24,12 @@
 
 if scipy_available:
     from pyomo.contrib.doe import DesignOfExperiments
-from pyomo.contrib.doe.examples.reactor_example import (
-    ReactorExperiment as FullReactorExperiment,
-)
-from pyomo.contrib.doe.tests.experiment_class_example_flags import (
-    FullReactorExperimentBad,
-)
+    from pyomo.contrib.doe.examples.reactor_example import (
+        ReactorExperiment as FullReactorExperiment,
+    )
+    from pyomo.contrib.doe.tests.experiment_class_example_flags import (
+        FullReactorExperimentBad,
+    )
 from pyomo.contrib.doe.utils import rescale_FIM
 
 import pyomo.environ as pyo
diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 88d3e196acd..295008d83e7 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -25,11 +25,12 @@
 
 if scipy_available:
     from pyomo.contrib.doe import DesignOfExperiments, FIMExternalGreyBox
-
-from pyomo.contrib.doe.examples.reactor_example import (
-    ReactorExperiment as FullReactorExperiment,
-)
-from pyomo.contrib.doe.examples.rooney_biegler_example import RooneyBieglerExperimentDoE
+    from pyomo.contrib.doe.examples.reactor_example import (
+        ReactorExperiment as FullReactorExperiment,
+    )
+    from pyomo.contrib.doe.examples.rooney_biegler_example import (
+        RooneyBieglerExperimentDoE,
+    )
 
 import pyomo.environ as pyo
 

From 844e1b8426c8f504e17dfbe213957230426a4259 Mon Sep 17 00:00:00 2001
From: djalky <dlakes94@gmail.com>
Date: Tue, 27 May 2025 15:27:29 -0400
Subject: [PATCH 103/143] Added specific solvers for the solve cases.

---
 pyomo/contrib/doe/tests/test_doe_build.py  |  8 +++++++-
 pyomo/contrib/doe/tests/test_doe_errors.py |  8 +++++++-
 pyomo/contrib/doe/tests/test_doe_solve.py  |  8 +++++++-
 pyomo/contrib/doe/tests/test_greybox.py    | 14 ++++++++++++++
 4 files changed, 35 insertions(+), 3 deletions(-)

diff --git a/pyomo/contrib/doe/tests/test_doe_build.py b/pyomo/contrib/doe/tests/test_doe_build.py
index 2941a1441c0..f19f5da8703 100644
--- a/pyomo/contrib/doe/tests/test_doe_build.py
+++ b/pyomo/contrib/doe/tests/test_doe_build.py
@@ -111,7 +111,13 @@ def get_standard_args(experiment, fd_method, obj_used):
     args['jac_initial'] = None
     args['fim_initial'] = None
     args['L_diagonal_lower_bound'] = 1e-7
-    args['solver'] = None
+    # Make solver object with
+    # good linear subroutines
+    solver = pyo.SolverFactory("ipopt")
+    solver.options["linear_solver"] = "ma57"
+    solver.options["halt_on_ampl_error"] = "yes"
+    solver.options["max_iter"] = 3000
+    args['solver'] = solver
     args['tee'] = False
     args['get_labeled_model_args'] = None
     args['_Cholesky_option'] = True
diff --git a/pyomo/contrib/doe/tests/test_doe_errors.py b/pyomo/contrib/doe/tests/test_doe_errors.py
index d646c55006f..5d48129c583 100644
--- a/pyomo/contrib/doe/tests/test_doe_errors.py
+++ b/pyomo/contrib/doe/tests/test_doe_errors.py
@@ -52,7 +52,13 @@ def get_standard_args(experiment, fd_method, obj_used, flag):
     args['jac_initial'] = None
     args['fim_initial'] = None
     args['L_diagonal_lower_bound'] = 1e-7
-    args['solver'] = None
+    # Make solver object with
+    # good linear subroutines
+    solver = pyo.SolverFactory("ipopt")
+    solver.options["linear_solver"] = "ma57"
+    solver.options["halt_on_ampl_error"] = "yes"
+    solver.options["max_iter"] = 3000
+    args['solver'] = solver
     args['tee'] = False
     args['get_labeled_model_args'] = {"flag": flag}
     args['_Cholesky_option'] = True
diff --git a/pyomo/contrib/doe/tests/test_doe_solve.py b/pyomo/contrib/doe/tests/test_doe_solve.py
index 9b8bbfe56ff..71cb9a54c06 100644
--- a/pyomo/contrib/doe/tests/test_doe_solve.py
+++ b/pyomo/contrib/doe/tests/test_doe_solve.py
@@ -111,7 +111,13 @@ def get_standard_args(experiment, fd_method, obj_used):
     args['jac_initial'] = None
     args['fim_initial'] = None
     args['L_diagonal_lower_bound'] = 1e-7
-    args['solver'] = None
+    # Make solver object with
+    # good linear subroutines
+    solver = pyo.SolverFactory("ipopt")
+    solver.options["linear_solver"] = "ma57"
+    solver.options["halt_on_ampl_error"] = "yes"
+    solver.options["max_iter"] = 3000
+    args['solver'] = solver
     args['tee'] = False
     args['get_labeled_model_args'] = None
     args['_Cholesky_option'] = True
diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 295008d83e7..33cbd99eabb 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -239,6 +239,20 @@ def get_standard_args(experiment, fd_method, obj_used):
     args['L_diagonal_lower_bound'] = 1e-7
     solver = SolverFactory("ipopt")
     args['solver'] = solver
+    # Make solver object with
+    # good linear subroutines
+    solver = pyo.SolverFactory("ipopt")
+    solver.options["linear_solver"] = "ma57"
+    solver.options["halt_on_ampl_error"] = "yes"
+    solver.options["max_iter"] = 3000
+    args['solver'] = solver
+    # Make greybox solver object with
+    # good linear subroutines
+    grey_box_solver = pyo.SolverFactory("cyipopt")
+    grey_box_solver.config.options["linear_solver"] = "ma57"
+    grey_box_solver.config.options['tol'] = 1e-4
+    grey_box_solver.config.options['mu_strategy'] = "monotone"
+    args['grey_box_solver'] = grey_box_solver
     args['tee'] = False
     args['get_labeled_model_args'] = None
     args['_Cholesky_option'] = True

From f6b34e91453cd4b7463178dde83da31b2fe06346 Mon Sep 17 00:00:00 2001
From: djalky <dlakes94@gmail.com>
Date: Tue, 27 May 2025 15:41:04 -0400
Subject: [PATCH 104/143] Adding test skipping if numpy and scipy are not
 available.

---
 pyomo/contrib/doe/tests/test_doe_build.py  | 4 ++++
 pyomo/contrib/doe/tests/test_doe_errors.py | 5 +++++
 pyomo/contrib/doe/tests/test_doe_solve.py  | 4 ++++
 pyomo/contrib/doe/tests/test_greybox.py    | 4 ++++
 4 files changed, 17 insertions(+)

diff --git a/pyomo/contrib/doe/tests/test_doe_build.py b/pyomo/contrib/doe/tests/test_doe_build.py
index f19f5da8703..62f314cb03c 100644
--- a/pyomo/contrib/doe/tests/test_doe_build.py
+++ b/pyomo/contrib/doe/tests/test_doe_build.py
@@ -18,6 +18,10 @@
     pandas_available,
     scipy_available,
 )
+
+if not (numpy_available and scipy_available):
+    raise unittest.SkipTest("Pyomo.DoE needs scipy and numpy to run tests")
+
 from pyomo.common.fileutils import this_file_dir
 import pyomo.common.unittest as unittest
 
diff --git a/pyomo/contrib/doe/tests/test_doe_errors.py b/pyomo/contrib/doe/tests/test_doe_errors.py
index 5d48129c583..4ba787678da 100644
--- a/pyomo/contrib/doe/tests/test_doe_errors.py
+++ b/pyomo/contrib/doe/tests/test_doe_errors.py
@@ -18,6 +18,11 @@
     pandas_available,
     scipy_available,
 )
+
+if not (numpy_available and scipy_available):
+    raise unittest.SkipTest("Pyomo.DoE needs scipy and numpy to run tests")
+
+
 from pyomo.common.fileutils import this_file_dir
 import pyomo.common.unittest as unittest
 
diff --git a/pyomo/contrib/doe/tests/test_doe_solve.py b/pyomo/contrib/doe/tests/test_doe_solve.py
index 71cb9a54c06..3f26fb3c92d 100644
--- a/pyomo/contrib/doe/tests/test_doe_solve.py
+++ b/pyomo/contrib/doe/tests/test_doe_solve.py
@@ -19,6 +19,10 @@
     pandas_available,
     scipy_available,
 )
+
+if not (numpy_available and scipy_available):
+    raise unittest.SkipTest("Pyomo.DoE needs scipy and numpy to run tests")
+
 from pyomo.common.fileutils import this_file_dir
 import pyomo.common.unittest as unittest
 
diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 33cbd99eabb..e6edcba3ad9 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -20,6 +20,10 @@
     pandas_available,
     scipy_available,
 )
+
+if not (numpy_available and scipy_available):
+    raise unittest.SkipTest("Pyomo.DoE needs scipy and numpy to run tests")
+
 from pyomo.common.fileutils import this_file_dir
 import pyomo.common.unittest as unittest
 

From 6c80755659f61b29d0bb829245e04b0a9966d1de Mon Sep 17 00:00:00 2001
From: djalky <dlakes94@gmail.com>
Date: Tue, 27 May 2025 16:02:29 -0400
Subject: [PATCH 105/143] Fixed `pyo` prefix problem.

---
 pyomo/contrib/doe/tests/test_doe_build.py  | 2 +-
 pyomo/contrib/doe/tests/test_doe_errors.py | 2 +-
 pyomo/contrib/doe/tests/test_doe_solve.py  | 2 +-
 pyomo/contrib/doe/tests/test_greybox.py    | 4 ++--
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/pyomo/contrib/doe/tests/test_doe_build.py b/pyomo/contrib/doe/tests/test_doe_build.py
index 62f314cb03c..cabb736f4f6 100644
--- a/pyomo/contrib/doe/tests/test_doe_build.py
+++ b/pyomo/contrib/doe/tests/test_doe_build.py
@@ -117,7 +117,7 @@ def get_standard_args(experiment, fd_method, obj_used):
     args['L_diagonal_lower_bound'] = 1e-7
     # Make solver object with
     # good linear subroutines
-    solver = pyo.SolverFactory("ipopt")
+    solver = SolverFactory("ipopt")
     solver.options["linear_solver"] = "ma57"
     solver.options["halt_on_ampl_error"] = "yes"
     solver.options["max_iter"] = 3000
diff --git a/pyomo/contrib/doe/tests/test_doe_errors.py b/pyomo/contrib/doe/tests/test_doe_errors.py
index 4ba787678da..0dddc87ba25 100644
--- a/pyomo/contrib/doe/tests/test_doe_errors.py
+++ b/pyomo/contrib/doe/tests/test_doe_errors.py
@@ -59,7 +59,7 @@ def get_standard_args(experiment, fd_method, obj_used, flag):
     args['L_diagonal_lower_bound'] = 1e-7
     # Make solver object with
     # good linear subroutines
-    solver = pyo.SolverFactory("ipopt")
+    solver = SolverFactory("ipopt")
     solver.options["linear_solver"] = "ma57"
     solver.options["halt_on_ampl_error"] = "yes"
     solver.options["max_iter"] = 3000
diff --git a/pyomo/contrib/doe/tests/test_doe_solve.py b/pyomo/contrib/doe/tests/test_doe_solve.py
index 3f26fb3c92d..6fcb905b5d7 100644
--- a/pyomo/contrib/doe/tests/test_doe_solve.py
+++ b/pyomo/contrib/doe/tests/test_doe_solve.py
@@ -117,7 +117,7 @@ def get_standard_args(experiment, fd_method, obj_used):
     args['L_diagonal_lower_bound'] = 1e-7
     # Make solver object with
     # good linear subroutines
-    solver = pyo.SolverFactory("ipopt")
+    solver = SolverFactory("ipopt")
     solver.options["linear_solver"] = "ma57"
     solver.options["halt_on_ampl_error"] = "yes"
     solver.options["max_iter"] = 3000
diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index e6edcba3ad9..c94129c40cb 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -245,14 +245,14 @@ def get_standard_args(experiment, fd_method, obj_used):
     args['solver'] = solver
     # Make solver object with
     # good linear subroutines
-    solver = pyo.SolverFactory("ipopt")
+    solver = SolverFactory("ipopt")
     solver.options["linear_solver"] = "ma57"
     solver.options["halt_on_ampl_error"] = "yes"
     solver.options["max_iter"] = 3000
     args['solver'] = solver
     # Make greybox solver object with
     # good linear subroutines
-    grey_box_solver = pyo.SolverFactory("cyipopt")
+    grey_box_solver = SolverFactory("cyipopt")
     grey_box_solver.config.options["linear_solver"] = "ma57"
     grey_box_solver.config.options['tol'] = 1e-4
     grey_box_solver.config.options['mu_strategy'] = "monotone"

From b77f5c704ea9686771965f1d9a2a0f5bb8933f24 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Wed, 28 May 2025 15:19:00 -0400
Subject: [PATCH 106/143] Added grey box tee separate from standard tee

---
 pyomo/contrib/doe/doe.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index 55c52785b0c..21f192edc5d 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -97,6 +97,7 @@ def __init__(
         solver=None,
         grey_box_solver=None,
         tee=False,
+        grey_box_tee=False,
         get_labeled_model_args=None,
         logger_level=logging.WARNING,
         _Cholesky_option=True,
@@ -213,6 +214,7 @@ def __init__(
             self.solver = solver
 
         self.tee = tee
+        self.grey_box_tee = grey_box_tee
 
         # ToDo: allow user to supply grey box solver
         if grey_box_solver:
@@ -415,7 +417,7 @@ def run_doe(self, model=None, results_file=None):
 
         # Solve the full model, which has now been initialized with the square solve
         if self.use_grey_box:
-            res = self.grey_box_solver.solve(model, tee=self.tee)
+            res = self.grey_box_solver.solve(model, tee=self.grey_box_tee)
         else:
             res = self.solver.solve(model, tee=self.tee)
 

From e676c933146b83b27ca71ec15c4cfa8ea83a5466 Mon Sep 17 00:00:00 2001
From: Daniel Laky <dlaky@crcfe01.crc.nd.edu>
Date: Thu, 29 May 2025 10:21:59 -0400
Subject: [PATCH 107/143] Adding terminationmessage to check for testing
 cyipopt

---
 pyomo/contrib/doe/doe.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index 21f192edc5d..82c2568a207 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -440,6 +440,7 @@ def run_doe(self, model=None, results_file=None):
 
         self.results["Solver Status"] = res.solver.status
         self.results["Termination Condition"] = res.solver.termination_condition
+        self.results["Termination Message"] = res.solver.message.decode("utf-8")
 
         # Important quantities for optimal design
         self.results["FIM"] = fim_local

From c2df2bd8195043355a97b21ae0cc6cb04491a16b Mon Sep 17 00:00:00 2001
From: Daniel Laky <dlaky@crcfe01.crc.nd.edu>
Date: Thu, 29 May 2025 10:22:57 -0400
Subject: [PATCH 108/143] adding check for if cyipopt call is working properly

---
 pyomo/contrib/doe/tests/test_greybox.py | 44 +++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index c94129c40cb..5423ea7d25d 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -258,6 +258,7 @@ def get_standard_args(experiment, fd_method, obj_used):
     grey_box_solver.config.options['mu_strategy'] = "monotone"
     args['grey_box_solver'] = grey_box_solver
     args['tee'] = False
+    args['grey_box_tee'] = True
     args['get_labeled_model_args'] = None
     args['_Cholesky_option'] = True
     args['_only_compute_fim_lower'] = True
@@ -326,6 +327,35 @@ def make_greybox_and_doe_objects_rooney_biegler(objective_option):
     return doe_obj, grey_box_object
 
 
+# Test whether or not cyipopt
+# is appropriately calling the
+# lienar solvers.
+bad_message = "Invalid option encountered."
+cyipopt_call_working = False
+if numpy_available and scipy_available and ipopt_available and cyipopt_available:
+    try:
+        objective_option = "determinant"
+        doe_object, _ = make_greybox_and_doe_objects_rooney_biegler(
+            objective_option=objective_option
+        )
+
+        # Use the grey box objective
+        doe_object.use_grey_box = True
+
+        # Change linear solvers to mumps
+        doe_object.solver.options["linear_solver"] = "mumps"
+        doe_object.grey_box_solver.config.options["linear_solver"] = "mumps"
+        doe_object.grey_box_solver.config.options["max_iter"] = 1
+
+        doe_object.run_doe()
+
+        cyipopt_call_working = not (
+            bad_message in doe_object.results["Termination Message"]
+        )
+    except:
+        cyipopt_call_working = False
+
+
 @unittest.skipIf(not ipopt_available, "The 'ipopt' command is not available")
 @unittest.skipIf(not numpy_available, "Numpy is not available")
 @unittest.skipIf(not scipy_available, "scipy is not available")
@@ -953,6 +983,9 @@ def test_evaluate_hessian_outputs_obj_lib_error(self):
 
     # Test all versions of solving
     # using grey box
+    @unittest.skipIf(
+        not cyipopt_call_working, "cyipopt is not properly accessing linear solvers"
+    )
     def test_solve_D_optimality_log_determinant(self):
         # Two locally optimal design points exist
         # (time, optimal objective value)
@@ -988,6 +1021,9 @@ def test_solve_D_optimality_log_determinant(self):
             )
         )
 
+    @unittest.skipIf(
+        not cyipopt_call_working, "cyipopt is not properly accessing linear solvers"
+    )
     def test_solve_A_optimality_trace_of_inverse(self):
         # Two locally optimal design points exist
         # (time, optimal objective value)
@@ -1026,6 +1062,9 @@ def test_solve_A_optimality_trace_of_inverse(self):
             )
         )
 
+    @unittest.skipIf(
+        not cyipopt_call_working, "cyipopt is not properly accessing linear solvers"
+    )
     def test_solve_E_optimality_minimum_eigenvalue(self):
         # Two locally optimal design points exist
         # (time, optimal objective value)
@@ -1046,6 +1085,8 @@ def test_solve_E_optimality_minimum_eigenvalue(self):
         # Solve the model
         doe_object.run_doe()
 
+        print(doe_object.results["Termination Message"])
+
         optimal_time_val = doe_object.results["Experiment Design"][0]
         optimal_obj_val = doe_object.model.objective()
 
@@ -1064,6 +1105,9 @@ def test_solve_E_optimality_minimum_eigenvalue(self):
             )
         )
 
+    @unittest.skipIf(
+        not cyipopt_call_working, "cyipopt is not properly accessing linear solvers"
+    )
     def test_solve_ME_optimality_condition_number(self):
         # Two locally optimal design points exist
         # (time, optimal objective value)

From cbc95660dddacfa3c908444ec5af0e72be96f914 Mon Sep 17 00:00:00 2001
From: Daniel Laky <dlaky@crcfe01.crc.nd.edu>
Date: Thu, 29 May 2025 10:38:10 -0400
Subject: [PATCH 109/143] making decoding bytestring more robust

---
 pyomo/contrib/doe/doe.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index 82c2568a207..6845a6f123c 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -440,7 +440,11 @@ def run_doe(self, model=None, results_file=None):
 
         self.results["Solver Status"] = res.solver.status
         self.results["Termination Condition"] = res.solver.termination_condition
-        self.results["Termination Message"] = res.solver.message.decode("utf-8")
+        if type(res.solver.message) is str:
+            results_message = res.solver.message
+        elif type(res.solver.message) is bytes:
+            results_message = res.solver.message.decode("utf-8")
+        self.results["Termination Message"] = results_message
 
         # Important quantities for optimal design
         self.results["FIM"] = fim_local

From 3398fb0531810d2573ac38b0c911f6e5d06fedea Mon Sep 17 00:00:00 2001
From: Daniel Laky <dlaky@crcfe01.crc.nd.edu>
Date: Thu, 29 May 2025 11:58:09 -0400
Subject: [PATCH 110/143] More verbose tracking for debugging

---
 pyomo/contrib/doe/tests/test_greybox.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 5423ea7d25d..56effeb1d74 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -1085,7 +1085,9 @@ def test_solve_E_optimality_minimum_eigenvalue(self):
         # Solve the model
         doe_object.run_doe()
 
+        print("Termination Message")
         print(doe_object.results["Termination Message"])
+        print("End Message")
 
         optimal_time_val = doe_object.results["Experiment Design"][0]
         optimal_obj_val = doe_object.model.objective()

From bf8e031df4a42a5b03e7656f9d6bba9c298a340f Mon Sep 17 00:00:00 2001
From: djalky <dlakes94@gmail.com>
Date: Thu, 29 May 2025 13:26:20 -0400
Subject: [PATCH 111/143] Moved descriptive message to D-optimal solve, ran
 black

---
 pyomo/contrib/doe/tests/test_doe_solve.py | 7 +++----
 pyomo/contrib/doe/tests/test_greybox.py   | 8 ++++----
 2 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/pyomo/contrib/doe/tests/test_doe_solve.py b/pyomo/contrib/doe/tests/test_doe_solve.py
index 6fcb905b5d7..d6c4d834bdc 100644
--- a/pyomo/contrib/doe/tests/test_doe_solve.py
+++ b/pyomo/contrib/doe/tests/test_doe_solve.py
@@ -207,9 +207,9 @@ def test_reactor_obj_det_solve(self):
         experiment = FullReactorExperiment(data_ex, 10, 3)
 
         DoE_args = get_standard_args(experiment, fd_method, obj_used)
-        DoE_args['scale_nominal_param_value'] = (
-            False  # Vanilla determinant solve needs this
-        )
+        DoE_args[
+            'scale_nominal_param_value'
+        ] = False  # Vanilla determinant solve needs this
         DoE_args['_Cholesky_option'] = False
         DoE_args['_only_compute_fim_lower'] = False
 
@@ -247,7 +247,6 @@ def test_reactor_obj_cholesky_solve(self):
         self.assertTrue(np.all(np.isclose(FIM, Q.T @ sigma_inv @ Q)))
 
     def test_reactor_obj_cholesky_solve_bad_prior(self):
-
         from pyomo.contrib.doe.doe import _SMALL_TOLERANCE_DEFINITENESS
 
         fd_method = "central"
diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 56effeb1d74..df9a74025f2 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -1003,6 +1003,10 @@ def test_solve_D_optimality_log_determinant(self):
         # Solve the model
         doe_object.run_doe()
 
+        print("Termination Message")
+        print(doe_object.results["Termination Message"])
+        print("End Message")
+
         optimal_time_val = doe_object.results["Experiment Design"][0]
         optimal_obj_val = np.log10(np.exp(pyo.value(doe_object.model.objective)))
 
@@ -1085,10 +1089,6 @@ def test_solve_E_optimality_minimum_eigenvalue(self):
         # Solve the model
         doe_object.run_doe()
 
-        print("Termination Message")
-        print(doe_object.results["Termination Message"])
-        print("End Message")
-
         optimal_time_val = doe_object.results["Experiment Design"][0]
         optimal_obj_val = doe_object.model.objective()
 

From ad6a0b6c53b38f795773b82e66862a3bfc02d512 Mon Sep 17 00:00:00 2001
From: Daniel Laky <dlaky@crcfe01.crc.nd.edu>
Date: Thu, 29 May 2025 13:30:32 -0400
Subject: [PATCH 112/143] reran black

---
 pyomo/contrib/doe/tests/test_doe_solve.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/pyomo/contrib/doe/tests/test_doe_solve.py b/pyomo/contrib/doe/tests/test_doe_solve.py
index d6c4d834bdc..1fdc3d837f8 100644
--- a/pyomo/contrib/doe/tests/test_doe_solve.py
+++ b/pyomo/contrib/doe/tests/test_doe_solve.py
@@ -207,9 +207,9 @@ def test_reactor_obj_det_solve(self):
         experiment = FullReactorExperiment(data_ex, 10, 3)
 
         DoE_args = get_standard_args(experiment, fd_method, obj_used)
-        DoE_args[
-            'scale_nominal_param_value'
-        ] = False  # Vanilla determinant solve needs this
+        DoE_args['scale_nominal_param_value'] = (
+            False  # Vanilla determinant solve needs this
+        )
         DoE_args['_Cholesky_option'] = False
         DoE_args['_only_compute_fim_lower'] = False
 

From 6913070e4f3b510b8d4ffa4b0bd27dcf78f706ef Mon Sep 17 00:00:00 2001
From: djalky <dlakes94@gmail.com>
Date: Thu, 29 May 2025 13:58:31 -0400
Subject: [PATCH 113/143] More test debugging.

---
 pyomo/contrib/doe/tests/test_greybox.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index df9a74025f2..cfd70672d4a 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -1005,6 +1005,8 @@ def test_solve_D_optimality_log_determinant(self):
 
         print("Termination Message")
         print(doe_object.results["Termination Message"])
+        print(cyipopt_call_working)
+        print(bad message in doe_object.results["Termination Message"])
         print("End Message")
 
         optimal_time_val = doe_object.results["Experiment Design"][0]

From b00ae6d63b1b0a807225efc6b7e5c6a385c18bcb Mon Sep 17 00:00:00 2001
From: djalky <dlakes94@gmail.com>
Date: Thu, 29 May 2025 14:13:00 -0400
Subject: [PATCH 114/143] fixed typo

---
 pyomo/contrib/doe/tests/test_greybox.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index cfd70672d4a..0db714c6c1a 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -1006,7 +1006,7 @@ def test_solve_D_optimality_log_determinant(self):
         print("Termination Message")
         print(doe_object.results["Termination Message"])
         print(cyipopt_call_working)
-        print(bad message in doe_object.results["Termination Message"])
+        print(bad_message in doe_object.results["Termination Message"])
         print("End Message")
 
         optimal_time_val = doe_object.results["Experiment Design"][0]

From 7b8277ff6d1d82e31a3ca8384907022132fd31df Mon Sep 17 00:00:00 2001
From: djalky <dlakes94@gmail.com>
Date: Thu, 29 May 2025 14:48:34 -0400
Subject: [PATCH 115/143] More debugging

---
 pyomo/contrib/doe/tests/test_greybox.py | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 0db714c6c1a..ebf3ecf2674 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -331,7 +331,7 @@ def make_greybox_and_doe_objects_rooney_biegler(objective_option):
 # is appropriately calling the
 # lienar solvers.
 bad_message = "Invalid option encountered."
-cyipopt_call_working = False
+cyipopt_call_working = True
 if numpy_available and scipy_available and ipopt_available and cyipopt_available:
     try:
         objective_option = "determinant"
@@ -349,12 +349,24 @@ def make_greybox_and_doe_objects_rooney_biegler(objective_option):
 
         doe_object.run_doe()
 
+        print("Precursor test termination message: ")
+        print(doe_object.results["Termination Message"])
+
         cyipopt_call_working = not (
             bad_message in doe_object.results["Termination Message"]
         )
+        print(
+            "cyipopt call working value in precursor test: {}".format(
+                cyipopt_call_working
+            )
+        )
     except:
         cyipopt_call_working = False
 
+print(
+    "cyipopt call working value after precursor test: {}".format(cyipopt_call_working)
+)
+
 
 @unittest.skipIf(not ipopt_available, "The 'ipopt' command is not available")
 @unittest.skipIf(not numpy_available, "Numpy is not available")
@@ -984,7 +996,7 @@ def test_evaluate_hessian_outputs_obj_lib_error(self):
     # Test all versions of solving
     # using grey box
     @unittest.skipIf(
-        not cyipopt_call_working, "cyipopt is not properly accessing linear solvers"
+        cyipopt_call_working, "cyipopt is not properly accessing linear solvers"
     )
     def test_solve_D_optimality_log_determinant(self):
         # Two locally optimal design points exist

From 3f9630806aa93db1ac831413c3efd7fa1fc8e095 Mon Sep 17 00:00:00 2001
From: djalky <dlakes94@gmail.com>
Date: Thu, 29 May 2025 14:50:53 -0400
Subject: [PATCH 116/143] Attempting ma57 failures.

---
 pyomo/contrib/doe/tests/test_greybox.py | 16 ++--------------
 1 file changed, 2 insertions(+), 14 deletions(-)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index ebf3ecf2674..a42ea9d32aa 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -343,30 +343,18 @@ def make_greybox_and_doe_objects_rooney_biegler(objective_option):
         doe_object.use_grey_box = True
 
         # Change linear solvers to mumps
-        doe_object.solver.options["linear_solver"] = "mumps"
-        doe_object.grey_box_solver.config.options["linear_solver"] = "mumps"
+        # doe_object.solver.options["linear_solver"] = "mumps"
+        # doe_object.grey_box_solver.config.options["linear_solver"] = "mumps"
         doe_object.grey_box_solver.config.options["max_iter"] = 1
 
         doe_object.run_doe()
 
-        print("Precursor test termination message: ")
-        print(doe_object.results["Termination Message"])
-
         cyipopt_call_working = not (
             bad_message in doe_object.results["Termination Message"]
         )
-        print(
-            "cyipopt call working value in precursor test: {}".format(
-                cyipopt_call_working
-            )
-        )
     except:
         cyipopt_call_working = False
 
-print(
-    "cyipopt call working value after precursor test: {}".format(cyipopt_call_working)
-)
-
 
 @unittest.skipIf(not ipopt_available, "The 'ipopt' command is not available")
 @unittest.skipIf(not numpy_available, "Numpy is not available")

From 30ad7f1df3874e7f6eb5cc239447d025151b331d Mon Sep 17 00:00:00 2001
From: djalky <dlakes94@gmail.com>
Date: Thu, 29 May 2025 15:03:00 -0400
Subject: [PATCH 117/143] Final bugfix for skipping cyipopt solves.

---
 pyomo/contrib/doe/tests/test_greybox.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index a42ea9d32aa..f05e75d11c8 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -984,7 +984,7 @@ def test_evaluate_hessian_outputs_obj_lib_error(self):
     # Test all versions of solving
     # using grey box
     @unittest.skipIf(
-        cyipopt_call_working, "cyipopt is not properly accessing linear solvers"
+        not cyipopt_call_working, "cyipopt is not properly accessing linear solvers"
     )
     def test_solve_D_optimality_log_determinant(self):
         # Two locally optimal design points exist

From 6a044154720cf48e88b879dc9f0950e6db85c590 Mon Sep 17 00:00:00 2001
From: djalky <dlakes94@gmail.com>
Date: Thu, 29 May 2025 16:41:47 -0400
Subject: [PATCH 118/143] Fixing import issues and removing old debug stuff

---
 pyomo/contrib/doe/grey_box_utilities.py | 57 ++++---------------------
 1 file changed, 8 insertions(+), 49 deletions(-)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index 57cf71c687a..de34b3e0487 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -25,20 +25,12 @@
 #  publicly, and to permit other to do so.
 #  ___________________________________________________________________________
 
-from pyomo.common.dependencies import numpy as np, scipy_available
+from pyomo.common.dependencies import numpy as np, scipy
 
 from enum import Enum
 import itertools
 import logging
 
-if not scipy_available:
-    raise ImportError(
-        "The scipy module is not available. "
-        "You need scipy to utilize the grey "
-        "box functionalities in Pyomo.DoE."
-    )
-from scipy.sparse import coo_matrix
-
 from pyomo.contrib.pynumero.interfaces.external_grey_box import ExternalGreyBoxModel
 
 import pyomo.environ as pyo
@@ -78,13 +70,11 @@ def __init__(self, doe_object, objective_option="determinant", logger_level=None
         self._n_params = len(self._param_names)
 
         # Check if the doe_object has model components that are required
-        # TODO: add checks for the model --> doe_object.model needs FIM; all other checks should
-        #       have been satisfied before the FIM is created. Can add check for unknown_parameters...
+        # TODO: is this check necessary?
         from pyomo.contrib.doe import ObjectiveLib
 
         objective_option = ObjectiveLib(objective_option)
         self.objective_option = objective_option
-        # Will anyone ever call this without calling DoE? --> intended to be no; but maybe more utility?
 
         # Create logger for FIM egb object
         self.logger = logging.getLogger(__name__)
@@ -98,12 +88,10 @@ def __init__(self, doe_object, objective_option="determinant", logger_level=None
         # Set initial values for inputs
         # Need a mask structure
         self._masking_matrix = np.triu(np.ones_like(self.doe_object.fim_initial))
-        # self._input_values = np.asarray(self.doe_object.fim_initial.flatten(), dtype=np.float64)
         self._input_values = np.asarray(
             self.doe_object.fim_initial[self._masking_matrix > 0], dtype=np.float64
         )
         self._n_inputs = len(self._input_values)
-        # print(self._input_values)
 
     def _get_FIM(self):
         # Grabs the current FIM subject
@@ -127,7 +115,6 @@ def input_names(self):
         # Cartesian product gives us matrix indices flattened in row-first format
         # Can use itertools.combinations(self._param_names, 2) with added
         # diagonal elements, or do double for loops if we switch to upper triangular
-        # input_names_list = list(itertools.product(self._param_names, self._param_names))
         input_names_list = list(
             itertools.combinations_with_replacement(self._param_names, 2)
         )
@@ -159,7 +146,6 @@ def output_names(self):
     def set_input_values(self, input_values):
         # Set initial values to be flattened initial FIM (aligns with input names)
         np.copyto(self._input_values, input_values)
-        # self._input_values = list(self.doe_object.fim_initial.flatten())
 
     def evaluate_equality_constraints(self):
         # ToDo: are there any objectives that will have constraints?
@@ -169,7 +155,6 @@ def evaluate_outputs(self):
         # Evaluates the objective value for the specified
         # ObjectiveLib type.
         current_FIM = self._get_FIM()
-        # current_FIM = self._input_values
 
         M = np.asarray(current_FIM, dtype=np.float64).reshape(
             self._n_params, self._n_params
@@ -192,8 +177,6 @@ def evaluate_outputs(self):
         else:
             ObjectiveLib(self.objective_option)
 
-        # print(obj_value)
-
         return np.asarray([obj_value], dtype=np.float64)
 
     def finalize_block_construction(self, pyomo_block):
@@ -234,25 +217,17 @@ def evaluate_jacobian_outputs(self):
         # Compute the jacobian of the objective function with
         # respect to the fisher information matrix. Then return
         # a coo_matrix that aligns with what IPOPT will expect.
-        #
-        # ToDo: there will be significant bookkeeping for more
-        # complicated objective functions and the Hessian
         current_FIM = self._get_FIM()
-        # current_FIM = self._input_values
+
         M = np.asarray(current_FIM, dtype=np.float64).reshape(
             self._n_params, self._n_params
         )
 
-        # print(current_FIM)
-
-        # May remove this warning. If so, we
-        # should put the eigenvalue computation
-        # within the eigenvalue-dependent
-        # objective options...
+        # ToDo: Add inertia correction for
+        #       negative/small eigenvalues
         eig_vals, eig_vecs = np.linalg.eig(M)
-        if min(eig_vals) <= 1:
+        if min(eig_vals) <= 1e-3:
             pass
-            # print("Warning: {:0.6f}".format(min(eig_vals)))
 
         from pyomo.contrib.doe import ObjectiveLib
 
@@ -323,30 +298,14 @@ def evaluate_jacobian_outputs(self):
         else:
             ObjectiveLib(self.objective_option)
 
-        # print(jac_M)
         # Filter jac_M using the
         # masking matrix
         jac_M = jac_M[self._masking_matrix > 0]
-        # M_rows = np.zeros_like(jac_M)
-        # M_cols = np.arange(len(jac_M))
-
-        # # Rows are the integer division by number of columns
-        # M_rows = np.arange(len(jac_M.flatten())) // jac_M.shape[1]
-
-        # # Columns are the remaindar (mod) by number of rows
-        # M_cols = np.arange(len(jac_M.flatten())) % jac_M.shape[0]
-
-        # Need to be flat?
         M_rows = np.zeros((len(jac_M.flatten()), 1)).flatten()
-
-        # Need to be flat?
         M_cols = np.arange(len(jac_M.flatten()))
 
         # Returns coo_matrix of the correct shape
-        # print(coo_matrix((jac_M.flatten(), (M_rows, M_cols)), shape=(1, len(jac_M.flatten()))))
-        # print(jac_M)
-        # print(self.input_names())
-        return coo_matrix(
+        return scipy.coo_matrix(
             (jac_M.flatten(), (M_rows, M_cols)), shape=(1, len(jac_M.flatten()))
         )
 
@@ -517,7 +476,7 @@ def evaluate_hessian_outputs(self, FIM=None):
             ObjectiveLib(self.objective_option)
 
         # Returns coo_matrix of the correct shape
-        return coo_matrix(
+        return scipy.coo_matrix(
             (np.asarray(hess_vals), (hess_rows, hess_cols)),
             shape=(self._n_inputs, self._n_inputs),
         )

From 750cd48d694e9f5b81be079e4ff2653f82115781 Mon Sep 17 00:00:00 2001
From: djalky <dlakes94@gmail.com>
Date: Thu, 29 May 2025 17:11:46 -0400
Subject: [PATCH 119/143] fixed scipy bug

---
 pyomo/contrib/doe/grey_box_utilities.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index de34b3e0487..89faf002202 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -305,7 +305,7 @@ def evaluate_jacobian_outputs(self):
         M_cols = np.arange(len(jac_M.flatten()))
 
         # Returns coo_matrix of the correct shape
-        return scipy.coo_matrix(
+        return scipy.sparse.coo_matrix(
             (jac_M.flatten(), (M_rows, M_cols)), shape=(1, len(jac_M.flatten()))
         )
 
@@ -476,7 +476,7 @@ def evaluate_hessian_outputs(self, FIM=None):
             ObjectiveLib(self.objective_option)
 
         # Returns coo_matrix of the correct shape
-        return scipy.coo_matrix(
+        return scipy.sparse.coo_matrix(
             (np.asarray(hess_vals), (hess_rows, hess_cols)),
             shape=(self._n_inputs, self._n_inputs),
         )

From 3b03fda6621dad461ba358abafec6a27b07f0dbe Mon Sep 17 00:00:00 2001
From: djalky <dlakes94@gmail.com>
Date: Tue, 3 Jun 2025 15:58:08 -0400
Subject: [PATCH 120/143] Add `lazy` safe pynumero imports

---
 pyomo/contrib/doe/grey_box_utilities.py | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index 89faf002202..21fad60a956 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -25,13 +25,19 @@
 #  publicly, and to permit other to do so.
 #  ___________________________________________________________________________
 
-from pyomo.common.dependencies import numpy as np, scipy
+from pyomo.common.dependencies import (
+    numpy as np,
+    numpy_available,
+    scipy,
+    scipy_available,
+)
 
 from enum import Enum
 import itertools
 import logging
 
-from pyomo.contrib.pynumero.interfaces.external_grey_box import ExternalGreyBoxModel
+if scipy_available and numpy_available:
+    from pyomo.contrib.pynumero.interfaces.external_grey_box import ExternalGreyBoxModel
 
 import pyomo.environ as pyo
 

From 76830f785883f3dce85298044c2edd2393917553 Mon Sep 17 00:00:00 2001
From: djalky <dlakes94@gmail.com>
Date: Tue, 3 Jun 2025 16:30:11 -0400
Subject: [PATCH 121/143] Add safe pynumero imports to doe.py as well

---
 pyomo/contrib/doe/doe.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index 6845a6f123c..84b768137c5 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -38,15 +38,17 @@
     pandas as pd,
     pathlib,
     matplotlib as plt,
+    scipy_available,
 )
 from pyomo.common.modeling import unique_component_name
 from pyomo.common.timing import TicTocTimer
 
 from pyomo.contrib.sensitivity_toolbox.sens import get_dsdp
 
-from pyomo.contrib.doe.grey_box_utilities import FIMExternalGreyBox
+if numpy_available and scipy_available:
+    from pyomo.contrib.doe.grey_box_utilities import FIMExternalGreyBox
 
-from pyomo.contrib.pynumero.interfaces.external_grey_box import ExternalGreyBoxBlock
+    from pyomo.contrib.pynumero.interfaces.external_grey_box import ExternalGreyBoxBlock
 
 import pyomo.environ as pyo
 

From 635af52333719ce7431e33e0dc1fcbeb78a4f132 Mon Sep 17 00:00:00 2001
From: djalky <dlakes94@gmail.com>
Date: Tue, 3 Jun 2025 16:37:06 -0400
Subject: [PATCH 122/143] Added safe object naming for FIMExternalGreyBox

---
 pyomo/contrib/doe/grey_box_utilities.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index 21fad60a956..0bed8111b42 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -42,7 +42,9 @@
 import pyomo.environ as pyo
 
 
-class FIMExternalGreyBox(ExternalGreyBoxModel):
+class FIMExternalGreyBox(
+    ExternalGreyBoxModel if (scipy_available and numpy_available) else object
+):
     def __init__(self, doe_object, objective_option="determinant", logger_level=None):
         """
         Grey box model for metrics on the FIM. This methodology reduces numerical complexity for the

From faeadee1afd3fc5734f535b7478fd7959b23c6ca Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Wed, 4 Jun 2025 08:45:38 -0400
Subject: [PATCH 123/143] Moved scipy/numpy skip check in testing

---
 pyomo/contrib/doe/tests/test_doe_build.py  | 6 +++---
 pyomo/contrib/doe/tests/test_doe_errors.py | 7 +++----
 pyomo/contrib/doe/tests/test_doe_solve.py  | 5 +++--
 pyomo/contrib/doe/tests/test_greybox.py    | 6 +++---
 4 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/pyomo/contrib/doe/tests/test_doe_build.py b/pyomo/contrib/doe/tests/test_doe_build.py
index cabb736f4f6..e3eac842b22 100644
--- a/pyomo/contrib/doe/tests/test_doe_build.py
+++ b/pyomo/contrib/doe/tests/test_doe_build.py
@@ -19,12 +19,12 @@
     scipy_available,
 )
 
-if not (numpy_available and scipy_available):
-    raise unittest.SkipTest("Pyomo.DoE needs scipy and numpy to run tests")
-
 from pyomo.common.fileutils import this_file_dir
 import pyomo.common.unittest as unittest
 
+if not (numpy_available and scipy_available):
+    raise unittest.SkipTest("Pyomo.DoE needs scipy and numpy to run tests")
+
 if scipy_available:
     from pyomo.contrib.doe import DesignOfExperiments
     from pyomo.contrib.doe.examples.reactor_example import (
diff --git a/pyomo/contrib/doe/tests/test_doe_errors.py b/pyomo/contrib/doe/tests/test_doe_errors.py
index 0dddc87ba25..b369a2b672c 100644
--- a/pyomo/contrib/doe/tests/test_doe_errors.py
+++ b/pyomo/contrib/doe/tests/test_doe_errors.py
@@ -19,13 +19,12 @@
     scipy_available,
 )
 
-if not (numpy_available and scipy_available):
-    raise unittest.SkipTest("Pyomo.DoE needs scipy and numpy to run tests")
-
-
 from pyomo.common.fileutils import this_file_dir
 import pyomo.common.unittest as unittest
 
+if not (numpy_available and scipy_available):
+    raise unittest.SkipTest("Pyomo.DoE needs scipy and numpy to run tests")
+
 if scipy_available:
     from pyomo.contrib.doe import DesignOfExperiments
     from pyomo.contrib.doe.tests.experiment_class_example_flags import (
diff --git a/pyomo/contrib/doe/tests/test_doe_solve.py b/pyomo/contrib/doe/tests/test_doe_solve.py
index 1fdc3d837f8..f4fd72045c4 100644
--- a/pyomo/contrib/doe/tests/test_doe_solve.py
+++ b/pyomo/contrib/doe/tests/test_doe_solve.py
@@ -20,12 +20,13 @@
     scipy_available,
 )
 
-if not (numpy_available and scipy_available):
-    raise unittest.SkipTest("Pyomo.DoE needs scipy and numpy to run tests")
 
 from pyomo.common.fileutils import this_file_dir
 import pyomo.common.unittest as unittest
 
+if not (numpy_available and scipy_available):
+    raise unittest.SkipTest("Pyomo.DoE needs scipy and numpy to run tests")
+
 if scipy_available:
     from pyomo.contrib.doe import DesignOfExperiments
     from pyomo.contrib.doe.examples.reactor_example import (
diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index f05e75d11c8..38cb209960f 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -21,12 +21,12 @@
     scipy_available,
 )
 
-if not (numpy_available and scipy_available):
-    raise unittest.SkipTest("Pyomo.DoE needs scipy and numpy to run tests")
-
 from pyomo.common.fileutils import this_file_dir
 import pyomo.common.unittest as unittest
 
+if not (numpy_available and scipy_available):
+    raise unittest.SkipTest("Pyomo.DoE needs scipy and numpy to run tests")
+
 if scipy_available:
     from pyomo.contrib.doe import DesignOfExperiments, FIMExternalGreyBox
     from pyomo.contrib.doe.examples.reactor_example import (

From e00d856ab189ad445b3b172e27a3cc0c6e45c884 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Wed, 11 Jun 2025 09:26:22 -0400
Subject: [PATCH 124/143] Starting wrap of Pyomo.DoE code to 88 lines

---
 pyomo/contrib/doe/doe.py | 69 +++++++++++++++++++++++-----------------
 1 file changed, 40 insertions(+), 29 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index 84b768137c5..ea048ed5a8e 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -115,42 +115,51 @@ def __init__(
         Parameters
         ----------
         experiment:
-            Experiment object that holds the model and labels all the components. The object
-            should have a ``get_labeled_model`` where a model is returned with the following
-            labeled sets: ``unknown_parameters``, ``experimental_inputs``, ``experimental_outputs``
+            Experiment object that holds the model and labels all the components. The
+            object should have a ``get_labeled_model`` where a model is returned with
+            the following labeled sets: ``unknown_parameters``,
+                                        ``experimental_inputs``,
+                                        ``experimental_outputs``
         fd_formula:
-            Finite difference formula for computing the sensitivity matrix. Must be one of
-            [``central``, ``forward``, ``backward``], default: ``central``
+            Finite difference formula for computing the sensitivity matrix. Must be
+            one of [``central``, ``forward``, ``backward``], default: ``central``
         step:
             Relative step size for the finite difference formula.
             default: 1e-3
         objective_option:
-            String representation of the objective option. Current available options are:
-            ``determinant`` (for determinant, or D-optimality) and ``trace`` (for trace or
-            A-optimality)
+            String representation of the objective option. Current available options
+            are: ``determinant`` (for determinant, or D-optimality),
+            ``trace`` (for trace, or A-optimality), ``minimum_eigenvalue``, (for
+            E-optimality), or ``condition_number`` (for ME-optimality)
+            Note: E-optimality and ME-optimality are only supported when using the
+            grey box objective (i.e., ``grey_box_solver`` is True)
+            default: ``determinant``
         use_grey_box_objective:
-            Boolean of whether or not to use the grey-box version of the objective function.
-            True to use grey box, False to use standard. Default: False (do not use grey box)
+            Boolean of whether or not to use the grey-box version of the objective
+            function. True to use grey box, False to use standard.
+            Default: False (do not use grey box)
         scale_constant_value:
-            Constant scaling for the sensitivity matrix. Every element will be multiplied by this
-            scaling factor.
+            Constant scaling for the sensitivity matrix. Every element will be
+            multiplied by this scaling factor.
             default: 1
         scale_nominal_param_value:
-            Boolean for whether or not to scale the sensitivity matrix by the nominal parameter
-            values. Every column of the sensitivity matrix will be divided by the respective
-            nominal parameter value.
+            Boolean for whether or not to scale the sensitivity matrix by the
+            nominal parameter values. Every column of the sensitivity matrix
+            will be divided by the respective nominal parameter value.
             default: False
         prior_FIM:
-            2D numpy array representing information from prior experiments. If no value is given,
-            the assumed prior will be a matrix of zeros. This matrix will be assumed to be scaled
-            as the user has specified (i.e., if scale_nominal_param_value is true, we will assume
-            the FIM provided here has been scaled by the parameter values)
+            2D numpy array representing information from prior experiments. If
+            no value is given, the assumed prior will be a matrix of zeros. This
+            matrix will be assumed to be scaled as the user has specified (i.e.,
+            if scale_nominal_param_value is true, we will assume the FIM provided
+            here has been scaled by the parameter values)
         jac_initial:
             2D numpy array as the initial values for the sensitivity matrix.
         fim_initial:
             2D numpy array as the initial values for the FIM.
         L_diagonal_lower_bound:
-            Lower bound for the values of the lower triangular Cholesky factorization matrix.
+            Lower bound for the values of the lower triangular Cholesky factorization
+            matrix.
             default: 1e-7
         solver:
             A ``solver`` object specified by the user, default=None.
@@ -158,16 +167,17 @@ def __init__(
         tee:
             Solver option to be passed for verbose output.
         get_labeled_model_args:
-            Additional arguments for the ``get_labeled_model`` function on the Experiment object.
+            Additional arguments for the ``get_labeled_model`` function on the
+            Experiment object.
         _Cholesky_option:
-            Boolean value of whether or not to use the cholesky factorization to compute the
-            determinant for the D-optimality criteria. This parameter should not be changed
-            unless the user intends to make performance worse (i.e., compare an existing tool
-            that uses the full FIM to this algorithm)
+            Boolean value of whether or not to use the cholesky factorization to
+            compute the determinant for the D-optimality criteria. This parameter
+            should not be changed unless the user intends to make performance worse
+            (i.e., compare an existing tool that uses the full FIM to this algorithm)
         _only_compute_fim_lower:
-            If True, only the lower triangle of the FIM is computed. This parameter should not
-            be changed unless the user intends to make performance worse (i.e., compare an
-            existing tool that uses the full FIM to this algorithm)
+            If True, only the lower triangle of the FIM is computed. This parameter
+            should not be changed unless the user intends to make performance worse
+            (i.e., compare an existing tool that uses the full FIM to this algorithm)
         logger_level:
             Specify the level of the logger. Change to logging.DEBUG for all messages.
         """
@@ -322,7 +332,8 @@ def run_doe(self, model=None, results_file=None):
         # if pyo.check_optimal_termination(res):
         #     model.load_solution(res)
         # else:
-        #     # The solver was unsuccessful, might want to warn the user or terminate gracefully, etc.
+        #     # The solver was unsuccessful, might want to warn the user
+        #     # or terminate gracefully, etc.
         model.dummy_obj = pyo.Objective(expr=0, sense=pyo.minimize)
         self.solver.solve(model, tee=self.tee)
 

From 1965bcfcdc380bada57ee617282e604b9c52dfc9 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Wed, 11 Jun 2025 09:34:13 -0400
Subject: [PATCH 125/143] More 88-line wrapping fixes

---
 pyomo/contrib/doe/doe.py | 55 +++++++++++++++++++++++++++-------------
 1 file changed, 37 insertions(+), 18 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index ea048ed5a8e..0e4fe7d5a4b 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -294,7 +294,8 @@ def run_doe(self, model=None, results_file=None):
         else:
             # TODO: Add safe naming when a model is passed by the user.
             # doe_block = pyo.Block()
-            # doe_block_name = unique_component_name(model, "design_of_experiments_block")
+            # doe_block_name = unique_component_name(model,
+            #                                        "design_of_experiments_block")
             # model.add_component(doe_block_name, doe_block)
             pass
 
@@ -340,8 +341,10 @@ def run_doe(self, model=None, results_file=None):
         # Track time to initialize the DoE model
         initialization_time = sp_timer.toc(msg=None)
         self.logger.info(
-            "Successfully initialized the DoE model.\nInitialization time: %0.1f seconds"
-            % initialization_time
+            (
+                "Successfully initialized the DoE model."
+                "\nInitialization time: %0.1f seconds" % initialization_time
+            )
         )
 
         model.dummy_obj.deactivate()
@@ -396,7 +399,8 @@ def run_doe(self, model=None, results_file=None):
                 (len(model.parameter_names), len(model.parameter_names))
             )
 
-            # Need to compute the full FIM before initializing the Cholesky factorization
+            # Need to compute the full FIM before
+            # initializing the Cholesky factorization
             if self.only_compute_fim_lower:
                 fim_np = fim_np + fim_np.T - np.diag(np.diag(fim_np))
 
@@ -406,7 +410,8 @@ def run_doe(self, model=None, results_file=None):
             min_eig = np.min(np.linalg.eigvals(fim_np))
 
             if min_eig < _SMALL_TOLERANCE_DEFINITENESS:
-                # Raise the minimum eigenvalue to at least _SMALL_TOLERANCE_DEFINITENESS
+                # Raise the minimum eigenvalue to at
+                # least _SMALL_TOLERANCE_DEFINITENESS
                 jitter = np.min(
                     [
                         -min_eig + _SMALL_TOLERANCE_DEFINITENESS,
@@ -438,7 +443,10 @@ def run_doe(self, model=None, results_file=None):
         solve_time = sp_timer.toc(msg=None)
 
         self.logger.info(
-            "Successfully optimized experiment.\nSolve time: %0.1f seconds" % solve_time
+            (
+                "Successfully optimized experiment."
+                "\nSolve time: %0.1f seconds" % solve_time
+            )
         )
         self.logger.info(
             "Total time for build, initialization, and solve: %0.1f seconds"
@@ -544,7 +552,8 @@ def compute_FIM(self, model=None, method="sequential"):
         else:
             # TODO: Add safe naming when a model is passed by the user.
             # doe_block = pyo.Block()
-            # doe_block_name = unique_component_name(model, "design_of_experiments_block")
+            # doe_block_name = unique_component_name(model,
+            #                                        "design_of_experiments_block")
             # model.add_component(doe_block_name, doe_block)
             # self.compute_FIM_model = model
             pass
@@ -576,8 +585,9 @@ def compute_FIM(self, model=None, method="sequential"):
             self._computed_FIM = self.kaug_FIM
         else:
             raise ValueError(
-                "The method provided, {}, must be either `sequential` or `kaug`".format(
-                    method
+                (
+                    "The method provided, {}, must be either `sequential`"
+                    "or `kaug`".format(method)
                 )
             )
 
@@ -604,7 +614,8 @@ def _sequential_FIM(self, model=None):
             model.del_component(model.parameter_scenarios)
         model.parameter_scenarios = pyo.Suffix(direction=pyo.Suffix.LOCAL)
 
-        # Populate parameter scenarios, and scenario inds based on finite difference scheme
+        # Populate parameter scenarios, and scenario
+        # inds based on finite difference scheme
         if self.fd_formula == FiniteDifferenceStep.central:
             model.parameter_scenarios.update(
                 (2 * ind, k) for ind, k in enumerate(model.unknown_parameters.keys())
@@ -624,7 +635,8 @@ def _sequential_FIM(self, model=None):
             model.scenarios = range(len(model.unknown_parameters) + 1)
         else:
             raise AttributeError(
-                "Finite difference option not recognized. Please contact the developers as you should not see this error."
+                "Finite difference option not recognized. Please "
+                "contact the developers as you should not see this error."
             )
 
         # Fix design variables
@@ -664,13 +676,17 @@ def _sequential_FIM(self, model=None):
                 res = self.solver.solve(model, tee=self.tee)
                 pyo.assert_optimal_termination(res)
             except:
-                # TODO: Make error message more verbose, i.e., add unknown parameter values so the
-                # user can try to solve the model instance outside of the pyomo.DoE framework.
+                # TODO: Make error message more verbose,
+                #       (i.e., add unknown parameter values so the user
+                #       can try to solve the model instance outside of
+                #       the pyomo.DoE framework)
                 raise RuntimeError(
-                    "Model from experiment did not solve appropriately. Make sure the model is well-posed."
+                    "Model from experiment did not solve appropriately."
+                    " Make sure the model is well-posed."
                 )
 
-            # Reset value of parameter to default value before computing finite difference perturbation
+            # Reset value of parameter to default value
+            # before computing finite difference perturbation
             param.set_value(model.unknown_parameters[param])
 
             # Extract the measurement values for the scenario and append
@@ -691,7 +707,8 @@ def _sequential_FIM(self, model=None):
         # Counting variable for loop
         i = 0
 
-        # Loop over parameter values and grab correct columns for finite difference calculation
+        # Loop over parameter values and grab correct
+        # columns for finite difference calculation
 
         for k, v in model.unknown_parameters.items():
             curr_step = v * self.step
@@ -720,8 +737,10 @@ def _sequential_FIM(self, model=None):
             # Increment the count
             i += 1
 
-        # ToDo: As more complex measurement error schemes are put in place, this needs to change
-        # Add independent (non-correlated) measurement error for FIM calculation
+        # ToDo: As more complex measurement error schemes
+        #       are put in place, this needs to change
+        # Add independent (non-correlated) measurement
+        # error for FIM calculation
         cov_y = np.zeros((len(model.measurement_error), len(model.measurement_error)))
         count = 0
         for k, v in model.measurement_error.items():

From 0a69d9731c537d13833255637d1897d06106c252 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Wed, 11 Jun 2025 09:41:28 -0400
Subject: [PATCH 126/143] Further 88-line wrapping cleanup

---
 pyomo/contrib/doe/doe.py | 44 ++++++++++++++++++++++++----------------
 1 file changed, 27 insertions(+), 17 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index 0e4fe7d5a4b..cfe1de1f8f2 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -586,7 +586,7 @@ def compute_FIM(self, model=None, method="sequential"):
         else:
             raise ValueError(
                 (
-                    "The method provided, {}, must be either `sequential`"
+                    "The method provided, {}, must be either `sequential` "
                     "or `kaug`".format(method)
                 )
             )
@@ -724,7 +724,8 @@ def _sequential_FIM(self, model=None):
                 col_1 = 0
                 col_2 = i
 
-            # If scale_nominal_param_value is active, scale by nominal parameter value (v)
+            # If scale_nominal_param_value is active, scale
+            # by nominal parameter value (v)
             scale_factor = (1.0 / curr_step) * self.scale_constant_value
             if self.scale_nominal_param_value:
                 scale_factor *= v
@@ -866,19 +867,23 @@ def create_doe_model(self, model=None):
         else:
             # TODO: Add safe naming when a model is passed by the user.
             # doe_block = pyo.Block()
-            # doe_block_name = unique_component_name(model, "design_of_experiments_block")
+            # doe_block_name = unique_component_name(model,
+            #                                        "design_of_experiments_block")
             # model.add_component(doe_block_name, doe_block)
             pass
 
-        # Developer recommendation: use the Cholesky decomposition for D-optimality
-        # The explicit formula is available for benchmarking purposes and is NOT recommended
+        # Developer recommendation: use the Cholesky
+        # decomposition for D-optimality. The explicit
+        # formula is available for benchmarking purposes
+        # and is NOT recommended.
         if (
             self.only_compute_fim_lower
             and self.objective_option == ObjectiveLib.determinant
             and not self.Cholesky_option
         ):
             raise ValueError(
-                "Cannot compute determinant with explicit formula if only_compute_fim_lower is True."
+                "Cannot compute determinant with explicit formula "
+                "if only_compute_fim_lower is True."
             )
 
         # Generate scenarios for finite difference formulae
@@ -917,7 +922,8 @@ def identity_matrix(m, i, j):
             dict_jac_initialize = {}
             for i, bu in enumerate(model.output_names):
                 for j, un in enumerate(model.parameter_names):
-                    # Jacobian is a numpy array, rows are experimental outputs, columns are unknown parameters
+                    # Jacobian is a numpy array, rows are experimental
+                    # outputs, columns are unknown parameters
                     dict_jac_initialize[(bu, un)] = self.jac_initial[i][j]
 
         # Initialize the Jacobian matrix
@@ -928,7 +934,9 @@ def initialize_jac(m, i, j):
             # Otherwise initialize to 0.1 (which is an arbitrary non-zero value)
             else:
                 raise AttributeError(
-                    "Jacobian being initialized when the jac_initial attribute is None. Please contact the developers as you should not see this error."
+                    "Jacobian being initialized when the jac_initial attribute "
+                    "is None. Please contact the developers as you should not "
+                    "see this error."
                 )
 
         model.sensitivity_jacobian = pyo.Var(
@@ -1033,7 +1041,9 @@ def read_prior(m, i, j):
             model.parameter_names, model.parameter_names, rule=read_prior
         )
 
-        # Off-diagonal elements are symmetric, so only half of the off-diagonal elements need to be specified.
+        # Off-diagonal elements are symmetric, so only
+        # half of the off-diagonal elements need to be
+        # specified.
         def fim_rule(m, p, q):
             """
             m: Pyomo model
@@ -1118,7 +1128,8 @@ def _generate_scenario_blocks(self, model=None):
 
         if self.n_measurement_error != self.n_experiment_outputs:
             raise ValueError(
-                "Number of experiment outputs, {}, and length of measurement error, {}, do not match. Please check model labeling.".format(
+                "Number of experiment outputs, {}, and length of measurement error, "
+                "{}, do not match. Please check model labeling.".format(
                     self.n_experiment_outputs, self.n_measurement_error
                 )
             )
@@ -1139,10 +1150,12 @@ def _generate_scenario_blocks(self, model=None):
         else:
             self.jac_initial = np.eye(self.n_experiment_outputs, self.n_parameters)
 
-        # Make a new Suffix to hold which scenarios are associated with parameters
+        # Make a new Suffix to hold which scenarios
+        # are associated with parameters
         model.parameter_scenarios = pyo.Suffix(direction=pyo.Suffix.LOCAL)
 
-        # Populate parameter scenarios, and scenario inds based on finite difference scheme
+        # Populate parameter scenarios, and scenario
+        # inds based on finite difference scheme
         if self.fd_formula == FiniteDifferenceStep.central:
             model.parameter_scenarios.update(
                 (2 * ind, k)
@@ -1164,13 +1177,10 @@ def _generate_scenario_blocks(self, model=None):
             model.scenarios = range(len(model.base_model.unknown_parameters) + 1)
         else:
             raise AttributeError(
-                "Finite difference option not recognized. Please contact the developers as you should not see this error."
+                "Finite difference option not recognized. Please contact "
+                "the developers as you should not see this error."
             )
 
-        # TODO: Allow Params for `unknown_parameters` and `experiment_inputs`
-        #       May need to make a new converter Param to Var that allows non-string names/references to be passed
-        #       Waiting on updates to the parmest params_to_vars utility function.....
-
         # Run base model to get initialized model and check model function
         for comp in model.base_model.experiment_inputs:
             comp.fix()

From 3591bd791ddc91c5d313af791d6aaec5d87e3fb3 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Wed, 11 Jun 2025 09:50:34 -0400
Subject: [PATCH 127/143] More 88-line wrapping cleanup

---
 pyomo/contrib/doe/doe.py | 102 +++++++++++++++++++++++++--------------
 1 file changed, 67 insertions(+), 35 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index cfe1de1f8f2..99830b25dae 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -1191,7 +1191,8 @@ def _generate_scenario_blocks(self, model=None):
             self.logger.info("Model from experiment solved.")
         except:
             raise RuntimeError(
-                "Model from experiment did not solve appropriately. Make sure the model is well-posed."
+                "Model from experiment did not solve appropriately. "
+                "Make sure the model is well-posed."
             )
 
         for comp in model.base_model.experiment_inputs:
@@ -1203,7 +1204,8 @@ def build_block_scenarios(b, s):
             m = b.model()
             b.transfer_attributes_from(m.base_model.clone())
 
-            # Forward/Backward difference have a stationary case (s == 0), no parameter to perturb
+            # Forward/Backward difference have a stationary
+            # case (s == 0), no parameter to perturb
             if self.fd_formula in [
                 FiniteDifferenceStep.forward,
                 FiniteDifferenceStep.backward,
@@ -1223,7 +1225,7 @@ def build_block_scenarios(b, s):
             elif self.fd_formula == FiniteDifferenceStep.forward:
                 diff = self.step  # Forward always positive
             else:
-                # To-Do: add an error message for this as not being implemented yet
+                # TODO: add an error message for this as not being implemented yet
                 diff = 0
                 pass
 
@@ -1244,8 +1246,8 @@ def build_block_scenarios(b, s):
 
         model.scenario_blocks = pyo.Block(model.scenarios, rule=build_block_scenarios)
 
-        # To-Do: this might have to change if experiment inputs have
-        # a different value in the Suffix (currently it is the CUID)
+        # TODO: this might have to change if experiment inputs have
+        #       a different value in the Suffix (currently it is the CUID)
         design_vars = [k for k, v in model.scenario_blocks[0].experiment_inputs.items()]
 
         # Add constraints to equate block design with global design:
@@ -1268,7 +1270,7 @@ def global_design_fixing(m, s):
         # Clean up the base model used to generate the scenarios
         model.del_component(model.base_model)
 
-        # ToDo: consider this logic? Multi-block systems need something more fancy
+        # TODO: consider this logic? Multi-block systems need something more fancy
         self._built_scenarios = True
 
     # Create objective function
@@ -1295,12 +1297,14 @@ def create_objective_function(self, model=None):
             ObjectiveLib.zero,
         ]:
             raise AttributeError(
-                "Objective option not recognized. Please contact the developers as you should not see this error."
+                "Objective option not recognized. Please contact the "
+                "developers as you should not see this error."
             )
 
         if not hasattr(model, "fim"):
             raise RuntimeError(
-                "Model provided does not have variable `fim`. Please make sure the model is built properly before creating the objective."
+                "Model provided does not have variable `fim`. Please make "
+                "sure the model is built properly before creating the objective."
             )
 
         small_number = 1e-10
@@ -1323,7 +1327,8 @@ def create_objective_function(self, model=None):
             # Calculate the eigenvalues of the FIM matrix
             eig = np.linalg.eigvals(fim)
 
-            # If the smallest eigenvalue is (practically) negative, add a diagonal matrix to make it positive definite
+            # If the smallest eigenvalue is (practically) negative,
+            # add a diagonal matrix to make it positive definite
             small_number = 1e-10
             if min(eig) < small_number:
                 fim = fim + np.eye(len(model.parameter_names)) * (
@@ -1379,12 +1384,14 @@ def determinant_general(b):
             for i in range(len(list_p)):
                 name_order = []
                 x_order = list_p[i]
-                # sigma_i is the value in the i-th position after the reordering \sigma
+                # sigma_i is the value in the i-th
+                # position after the reordering \sigma
                 for x in range(len(x_order)):
                     for y, element in enumerate(m.parameter_names):
                         if x_order[x] == y:
                             name_order.append(element)
-            # det(A) = sum_{\sigma \in \S_n} (sgn(\sigma) * \Prod_{i=1}^n a_{i,\sigma_i})
+            # det(A) = sum_{\sigma \in \S_n} (sgn(\sigma) *
+            #          \Prod_{i=1}^n a_{i,\sigma_i})
             det_perm = sum(
                 self._sgn(list_p[d])
                 * math.prod(
@@ -1405,7 +1412,8 @@ def determinant_general(b):
             )
 
         elif self.objective_option == ObjectiveLib.determinant:
-            # if not cholesky but determinant, calculating det and evaluate the OBJ with det
+            # if not Cholesky but determinant, calculating
+            # det and evaluate the OBJ with det
             model.determinant = pyo.Var(
                 initialize=np.linalg.det(fim), bounds=(small_number, None)
             )
@@ -1415,13 +1423,16 @@ def determinant_general(b):
             )
 
         elif self.objective_option == ObjectiveLib.trace:
-            # if not determinant or cholesky, calculating the OBJ with trace
+            # if not determinant or Cholesky, calculating
+            # the OBJ with trace
             model.trace = pyo.Var(initialize=np.trace(fim), bounds=(small_number, None))
             model.obj_cons.trace_rule = pyo.Constraint(rule=trace_calc)
             model.objective = pyo.Objective(
                 expr=pyo.log10(model.trace), sense=pyo.maximize
             )
 
+        # TODO: Add warning (should be unreachable) if the user calls
+        #       the grey box objectives with the standard model
         elif self.objective_option == ObjectiveLib.zero:
             # add dummy objective function
             model.objective = pyo.Objective(expr=0)
@@ -1558,7 +1569,8 @@ def check_model_FIM(self, model=None, FIM=None):
 
         if FIM.shape != (self.n_parameters, self.n_parameters):
             raise ValueError(
-                "Shape of FIM provided should be n parameters by n parameters, or {} by {}, FIM provided has shape {} by {}".format(
+                "Shape of FIM provided should be n parameters by n parameters, "
+                "or {} by {}, FIM provided has shape {} by {}".format(
                     self.n_parameters, self.n_parameters, FIM.shape[0], FIM.shape[1]
                 )
             )
@@ -1569,7 +1581,8 @@ def check_model_FIM(self, model=None, FIM=None):
         # Check if the FIM is positive definite
         if np.min(evals) < -_SMALL_TOLERANCE_DEFINITENESS:
             raise ValueError(
-                "FIM provided is not positive definite. It has one or more negative eigenvalue(s) less than -{:.1e}".format(
+                "FIM provided is not positive definite. It has one or more "
+                "negative eigenvalue(s) less than -{:.1e}".format(
                     _SMALL_TOLERANCE_DEFINITENESS
                 )
             )
@@ -1583,14 +1596,17 @@ def check_model_FIM(self, model=None, FIM=None):
             )
 
         self.logger.info(
-            "FIM provided matches expected dimensions from model and is approximately positive (semi) definite."
+            "FIM provided matches expected dimensions from model "
+            "and is approximately positive (semi) definite."
         )
 
     # Check the jacobian shape against what is expected from the model.
     def check_model_jac(self, jac=None):
         if jac.shape != (self.n_experiment_outputs, self.n_parameters):
             raise ValueError(
-                "Shape of Jacobian provided should be n experiment outputs by n parameters, or {} by {}, Jacobian provided has shape {} by {}".format(
+                "Shape of Jacobian provided should be n experiment outputs "
+                "by n parameters, or {} by {}, Jacobian provided has "
+                "shape {} by {}".format(
                     self.n_experiment_outputs,
                     self.n_parameters,
                     jac.shape[0],
@@ -1623,7 +1639,8 @@ def update_FIM_prior(self, model=None, FIM=None):
 
         if not hasattr(model, "fim"):
             raise RuntimeError(
-                "``fim`` is not defined on the model provided. Please build the model first."
+                "``fim`` is not defined on the model provided. "
+                "Please build the model first."
             )
 
         self.check_model_FIM(model=model, FIM=FIM)
@@ -1635,14 +1652,15 @@ def update_FIM_prior(self, model=None, FIM=None):
 
         self.logger.info("FIM prior has been updated.")
 
-    # ToDo: Add an update function for the parameter values? --> closed loop parameter estimation?
-    # Or leave this to the user?????
+    # TODO: Add an update function for the parameter values?
+    #       Closed loop parameter estimation?
     def update_unknown_parameter_values(self, model=None, param_vals=None):
         raise NotImplementedError(
             "Updating unknown parameter values not yet supported."
         )
 
-    # Evaluates FIM and statistics for a full factorial space (same as run_grid_search)
+    # Evaluates FIM and statistics for a
+    # full factorial space (same as run_grid_search)
     def compute_FIM_full_factorial(
         self, model=None, design_ranges=None, method="sequential"
     ):
@@ -1769,13 +1787,16 @@ def compute_FIM_full_factorial(
             A_opt = np.log10(np.trace(FIM))
             E_vals, E_vecs = np.linalg.eig(FIM)  # Grab eigenvalues
             E_ind = np.argmin(E_vals.real)  # Grab index of minima to check imaginary
-            # Warn the user if there is a ``large`` imaginary component (should not be)
+            # Warn the user if there is a ``large``
+            # imaginary component (should not be)
             if abs(E_vals.imag[E_ind]) > 1e-8:
                 self.logger.warning(
-                    "Eigenvalue has imaginary component greater than 1e-6, contact developers if this issue persists."
+                    "Eigenvalue has imaginary component greater than 1e-6, "
+                    "contact developers if this issue persists."
                 )
 
-            # If the real value is less than or equal to zero, set the E_opt value to nan
+            # If the real value is less than or equal to
+            # zero, set the E_opt value to np.nan
             if E_vals.real[E_ind] <= 0:
                 E_opt = np.nan
             else:
@@ -1814,23 +1835,32 @@ def draw_factorial_figure(
         log_scale=True,
     ):
         """
-        Extract results needed for drawing figures from the results dictionary provided by
-        the ``compute_FIM_full_factorial`` function.
+        Extract results needed for drawing figures from
+        the results dictionary provided by the
+        ``compute_FIM_full_factorial`` function.
 
         Draw either the 1D sensitivity curve or 2D heatmap.
 
         Parameters
         ----------
-        results: dictionary, results dictionary from ``compute_FIM_full_factorial``, default: None (self.fim_factorial_results)
+        results: dictionary, results dictionary from ``compute_FIM_full_factorial``
+                 default: None (self.fim_factorial_results)
         sensitivity_design_variables: a list, design variable names to draw sensitivity
-        fixed_design_variables: a dictionary, keys are the design variable names to be fixed, values are the value of it to be fixed.
+        fixed_design_variables: a dictionary, keys are the design variable names to be
+                                fixed, values are the value of it to be fixed.
         full_design_variable_names: a list, all the design variables in the problem.
         title_text: a string, name for the figure
-        xlabel_text: a string, label for the x-axis of the figure (default: last design variable name)
-            In a 1D sensitivity curve, it should be design variable by which the curve is drawn.
-            In a 2D heatmap, it should be the second design variable in the design_ranges
-        ylabel_text: a string, label for the y-axis of the figure (default: None (1D); first design variable name (2D))
-            A 1D sensitivity curve does not need it. In a 2D heatmap, it should be the first design variable in the dv_ranges
+        xlabel_text: a string, label for the x-axis of the figure
+                    default: last design variable name
+            In a 1D sensitivity curve, it should be design variable by
+            which the curve is drawn
+            In a 2D heatmap, it should be the second design variable
+            in the design_ranges
+        ylabel_text: a string, label for the y-axis of the figure
+                    default: None (1D); first design variable name (2D)
+            A 1D sensitivity curve does not need it.
+            In a 2D heatmap, it should be the first
+            design variable in the dv_ranges
         figure_file_name: string or Path, path to save the figure as
         font_axes: axes label font size
         font_tick: tick label font size
@@ -1840,7 +1870,8 @@ def draw_factorial_figure(
         if results is None:
             if not hasattr(self, "fim_factorial_results"):
                 raise RuntimeError(
-                    "Results must be provided or the compute_FIM_full_factorial function must be run."
+                    "Results must be provided or the "
+                    "compute_FIM_full_factorial function must be run."
                 )
             results = self.fim_factorial_results
             full_design_variable_names = [
@@ -1849,7 +1880,8 @@ def draw_factorial_figure(
         else:
             if full_design_variable_names is None:
                 raise ValueError(
-                    "If results object is provided, you must include all the design variable names."
+                    "If results object is provided, you must "
+                    "include all the design variable names."
                 )
 
         des_names = full_design_variable_names

From b2ed0b320555d3ec6d77033fa8b63156bd4c3e49 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Wed, 11 Jun 2025 09:54:35 -0400
Subject: [PATCH 128/143] Final 88-line wrapping in doe.py file

---
 pyomo/contrib/doe/doe.py | 51 +++++++++++++++++++++++++++-------------
 1 file changed, 35 insertions(+), 16 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index 99830b25dae..d95b70fc86b 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -1904,11 +1904,13 @@ def draw_factorial_figure(
 
         if not check_des_vars:
             raise ValueError(
-                "Fixed design variables do not all appear in the results object keys."
+                "Fixed design variables do not all appear "
+                "in the results object keys."
             )
         if not check_sens_vars:
             raise ValueError(
-                "Sensitivity design variables do not all appear in the results object keys."
+                "Sensitivity design variables do not all appear "
+                "in the results object keys."
             )
 
         # ToDo: Make it possible to plot pair-wise sensitivities for all variables
@@ -1922,7 +1924,8 @@ def draw_factorial_figure(
             sensitivity_design_variables
         ) != len(des_names):
             raise ValueError(
-                "Error: All design variables that are not used to generate sensitivity plots must be fixed."
+                "Error: All design variables that are not used to "
+                "generate sensitivity plots must be fixed."
             )
 
         if type(results) is dict:
@@ -1930,7 +1933,8 @@ def draw_factorial_figure(
         else:
             results_pd = results
 
-        # generate a combination of logic sentences to filter the results of the DOF needed.
+        # generate a combination of logic to
+        # filter the results of the DOF needed.
         # an example filter: (self.store_all_results_dataframe["CA0"]==5).
         if len(fixed_design_variables.keys()) != 0:
             filter = ""
@@ -1997,7 +2001,8 @@ def _curve1D(
         ----------
         title_text: name of the figure, a string
         xlabel_text: x label title, a string.
-            In a 1D sensitivity curve, it is the design variable by which the curve is drawn.
+            In a 1D sensitivity curve, it is the design
+            variable by which the curve is drawn.
         font_axes: axes label font size
         font_tick: tick label font size
         figure_file_name: string or Path, path to save the figure as
@@ -2005,7 +2010,7 @@ def _curve1D(
 
         Returns
         --------
-        4 Figures of 1D sensitivity curves for each criteria
+        4 Figures of 1D sensitivity curves for each criterion
         """
         if figure_file_name is not None:
             show_fig = False
@@ -2130,9 +2135,11 @@ def _heatmap(
         ----------
         title_text: name of the figure, a string
         xlabel_text: x label title, a string.
-            In a 2D heatmap, it should be the second design variable in the design_ranges
+            In a 2D heatmap, it should be the second
+            design variable in the design_ranges
         ylabel_text: y label title, a string.
-            In a 2D heatmap, it should be the first design variable in the dv_ranges
+            In a 2D heatmap, it should be the first
+            design variable in the dv_ranges
         font_axes: axes label font size
         font_tick: tick label font size
         figure_file_name: string or Path, path to save the figure as
@@ -2140,7 +2147,7 @@ def _heatmap(
 
         Returns
         --------
-        4 Figures of 2D heatmap for each criteria
+        4 Figures of 2D heatmap for each criterion
         """
         if figure_file_name is not None:
             show_fig = False
@@ -2311,7 +2318,8 @@ def get_FIM(self, model=None):
 
         if not hasattr(model, "fim"):
             raise RuntimeError(
-                "Model provided does not have variable `fim`. Please make sure the model is built properly before calling `get_FIM`"
+                "Model provided does not have variable `fim`. Please make sure "
+                "the model is built properly before calling `get_FIM`"
             )
 
         fim_vals = [
@@ -2351,7 +2359,9 @@ def get_sensitivity_matrix(self, model=None):
 
         if not hasattr(model, "sensitivity_jacobian"):
             raise RuntimeError(
-                "Model provided does not have variable `sensitivity_jacobian`. Please make sure the model is built properly before calling `get_sensitivity_matrix`"
+                "Model provided does not have variable `sensitivity_jacobian`. "
+                "Please make sure the model is built properly before calling "
+                "`get_sensitivity_matrix`"
             )
 
         Q_vals = [
@@ -2387,7 +2397,9 @@ def get_experiment_input_values(self, model=None):
         if not hasattr(model, "experiment_inputs"):
             if not hasattr(model, "scenario_blocks"):
                 raise RuntimeError(
-                    "Model provided does not have expected structure. Please make sure model is built properly before calling `get_experiment_input_values`"
+                    "Model provided does not have expected structure. "
+                    "Please make sure model is built properly before "
+                    "calling `get_experiment_input_values`"
                 )
 
             d_vals = [
@@ -2412,7 +2424,8 @@ def get_unknown_parameter_values(self, model=None):
 
         Returns
         -------
-        theta: 1D list of unknown parameter values at which this experiment was designed
+        theta: 1D list of unknown parameter values at which
+               this experiment was designed
 
         """
         if model is None:
@@ -2421,7 +2434,9 @@ def get_unknown_parameter_values(self, model=None):
         if not hasattr(model, "unknown_parameters"):
             if not hasattr(model, "scenario_blocks"):
                 raise RuntimeError(
-                    "Model provided does not have expected structure. Please make sure model is built properly before calling `get_unknown_parameter_values`"
+                    "Model provided does not have expected structure. Please make "
+                    "sure model is built properly before calling "
+                    "`get_unknown_parameter_values`"
                 )
 
             theta_vals = [
@@ -2455,7 +2470,9 @@ def get_experiment_output_values(self, model=None):
         if not hasattr(model, "experiment_outputs"):
             if not hasattr(model, "scenario_blocks"):
                 raise RuntimeError(
-                    "Model provided does not have expected structure. Please make sure model is built properly before calling `get_experiment_output_values`"
+                    "Model provided does not have expected structure. Please make "
+                    "sure model is built properly before calling "
+                    "`get_experiment_output_values`"
                 )
 
             y_hat_vals = [
@@ -2491,7 +2508,9 @@ def get_measurement_error_values(self, model=None):
         if not hasattr(model, "measurement_error"):
             if not hasattr(model, "scenario_blocks"):
                 raise RuntimeError(
-                    "Model provided does not have expected structure. Please make sure model is built properly before calling `get_measurement_error_values`"
+                    "Model provided does not have expected structure. Please make "
+                    "sure model is built properly before calling "
+                    "`get_measurement_error_values`"
                 )
 
             sigma_vals = [

From 066d8626f638f38cd319f8342043a2e754856ed3 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Wed, 11 Jun 2025 09:58:30 -0400
Subject: [PATCH 129/143] Reformatted grey_box_utilities to be 88 per line

---
 pyomo/contrib/doe/grey_box_utilities.py | 26 ++++++++++++++-----------
 1 file changed, 15 insertions(+), 11 deletions(-)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index 0bed8111b42..98ea3c3c093 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -47,23 +47,27 @@ class FIMExternalGreyBox(
 ):
     def __init__(self, doe_object, objective_option="determinant", logger_level=None):
         """
-        Grey box model for metrics on the FIM. This methodology reduces numerical complexity for the
-        computation of FIM metrics related to eigenvalue decomposition.
+        Grey box model for metrics on the FIM. This methodology reduces
+        numerical complexity for the computation of FIM metrics related
+        to eigenvalue decomposition.
 
         Parameters
         ----------
         doe_object:
-           Design of Experiments object that contains a built model (with sensitivity matrix, Q, and
-           fisher information matrix, FIM). The external grey box model will utilize elements of the
-           doe_object's model to build the FIM metric with consistent naming.
+           Design of Experiments object that contains a built model
+           (with sensitivity matrix, Q, and fisher information matrix, FIM).
+           The external grey box model will utilize elements of the
+           `doe_object` model to build the FIM metric with consistent naming.
         obj_option:
-           String representation of the objective option. Current available option is ``determinant``.
-           Other options that are planned to be implemented soon are ``minimum_eig`` (E-optimality),
-           and ``condition_number`` (modified E-optimality). default option is ``determinant``
+           String representation of the objective option. Current available
+           options are: ``determinant`` (D-optimality), ``trace`` (A-optimality),
+           ``minimum_eigenvalue`` (E-optimality), ``condition_number``
+           (modified E-optimality).
+           default: ``determinant``
         logger_level:
-           logging level to be specified if different from doe_object's logging level. default value
-           is None, or equivalently, use the logging level of doe_object. Use logging.DEBUG for all
-           messages.
+           logging level to be specified if different from doe_object's logging level.
+           default: None, or equivalently, use the logging level of doe_object.
+                    NOTE: Use logging.DEBUG for all messages.
         """
 
         if doe_object is None:

From 56e34b1a2f67e0b849d4a9b6f28b4c5b3da051b8 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Wed, 11 Jun 2025 10:00:11 -0400
Subject: [PATCH 130/143] Removed Param to Var swapping function comment

This functionality is no longer planning to be supported. Therefore, we have removed this `TODO` comment.
---
 pyomo/contrib/doe/utils.py | 36 ++----------------------------------
 1 file changed, 2 insertions(+), 34 deletions(-)

diff --git a/pyomo/contrib/doe/utils.py b/pyomo/contrib/doe/utils.py
index 24be6fd696a..57c5a7f27bc 100644
--- a/pyomo/contrib/doe/utils.py
+++ b/pyomo/contrib/doe/utils.py
@@ -54,7 +54,8 @@ def rescale_FIM(FIM, param_vals):
             (len(param_vals.shape) == 2) and (param_vals.shape[0] != 1)
         ):
             raise ValueError(
-                "param_vals should be a vector of dimensions: 1 by `n_params`. The shape you provided is {}.".format(
+                "param_vals should be a vector of dimensions: 1 by `n_params`. "
+                "The shape you provided is {}.".format(
                     param_vals.shape
                 )
             )
@@ -67,36 +68,3 @@ def rescale_FIM(FIM, param_vals):
     scaling_mat = (1 / param_vals).transpose().dot((1 / param_vals))
     scaled_FIM = np.multiply(FIM, scaling_mat)
     return scaled_FIM
-
-
-# TODO: Add swapping parameters for variables helper function
-# def get_parameters_from_suffix(suffix, fix_vars=False):
-#     """
-#     Finds the Params within the suffix provided. It will also check to see
-#     if there are Vars in the suffix provided. ``fix_vars`` will indicate
-#     if we should fix all the Vars in the set or not.
-#
-#     Parameters
-#     ----------
-#     suffix: pyomo Suffix object, contains the components to be checked
-#             as keys
-#     fix_vars: boolean, whether or not to fix the Vars, default = False
-#
-#     Returns
-#     -------
-#     param_list: list of Param
-#     """
-#     param_list = []
-#
-#     # FIX THE MODEL TREE ISSUE WHERE I GET base_model.<param> INSTEAD OF <param>
-#     # Check keys if they are Param or Var. Fix the vars if ``fix_vars`` is True
-#     for k, v in suffix.items():
-#         if isinstance(k, ParamData):
-#             param_list.append(k.name)
-#         elif isinstance(k, VarData):
-#             if fix_vars:
-#                 k.fix()
-#         else:
-#             pass  # ToDo: Write error for suffix keys that aren't ParamData or VarData
-#
-#     return param_list

From d61bcde1af696cbac350d7b9780d99a67f434c7e Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Wed, 11 Jun 2025 10:00:27 -0400
Subject: [PATCH 131/143] Ran Black

---
 pyomo/contrib/doe/utils.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/pyomo/contrib/doe/utils.py b/pyomo/contrib/doe/utils.py
index 57c5a7f27bc..94e8334d220 100644
--- a/pyomo/contrib/doe/utils.py
+++ b/pyomo/contrib/doe/utils.py
@@ -55,9 +55,7 @@ def rescale_FIM(FIM, param_vals):
         ):
             raise ValueError(
                 "param_vals should be a vector of dimensions: 1 by `n_params`. "
-                "The shape you provided is {}.".format(
-                    param_vals.shape
-                )
+                "The shape you provided is {}.".format(param_vals.shape)
             )
         if len(param_vals.shape) == 1:
             param_vals = np.array([param_vals])

From e61c10e7f0fa71d710b8afea66ba48ca26deb36a Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Wed, 11 Jun 2025 10:08:46 -0400
Subject: [PATCH 132/143] Also fixed testing errors file to be 88 per line

---
 pyomo/contrib/doe/tests/test_doe_errors.py | 64 ++++++++++++++--------
 1 file changed, 42 insertions(+), 22 deletions(-)

diff --git a/pyomo/contrib/doe/tests/test_doe_errors.py b/pyomo/contrib/doe/tests/test_doe_errors.py
index b369a2b672c..29f9b5f2644 100644
--- a/pyomo/contrib/doe/tests/test_doe_errors.py
+++ b/pyomo/contrib/doe/tests/test_doe_errors.py
@@ -185,7 +185,8 @@ def test_reactor_check_bad_prior_size(self):
 
         with self.assertRaisesRegex(
             ValueError,
-            "Shape of FIM provided should be n parameters by n parameters, or {} by {}, FIM provided has shape {} by {}".format(
+            "Shape of FIM provided should be n parameters by n parameters, "
+            "or {} by {}, FIM provided has shape {} by {}".format(
                 4, 4, prior_FIM.shape[0], prior_FIM.shape[1]
             ),
         ):
@@ -209,7 +210,8 @@ def test_reactor_check_bad_prior_negative_eigenvalue(self):
 
         with self.assertRaisesRegex(
             ValueError,
-            r"FIM provided is not positive definite. It has one or more negative eigenvalue\(s\) less than -{:.1e}".format(
+            r"FIM provided is not positive definite. It has one or more "
+            r"negative eigenvalue\(s\) less than -{:.1e}".format(
                 _SMALL_TOLERANCE_DEFINITENESS
             ),
         ):
@@ -256,9 +258,9 @@ def test_reactor_check_bad_jacobian_init_size(self):
 
         with self.assertRaisesRegex(
             ValueError,
-            "Shape of Jacobian provided should be n experiment outputs by n parameters, or {} by {}, Jacobian provided has shape {} by {}".format(
-                27, 4, jac_init.shape[0], jac_init.shape[1]
-            ),
+            "Shape of Jacobian provided should be n experiment outputs "
+            "by n parameters, or {} by {}, Jacobian provided has "
+            "shape {} by {}".format(27, 4, jac_init.shape[0], jac_init.shape[1]),
         ):
             doe_obj.create_doe_model()
 
@@ -277,7 +279,8 @@ def test_reactor_check_unbuilt_update_FIM(self):
 
         with self.assertRaisesRegex(
             RuntimeError,
-            "``fim`` is not defined on the model provided. Please build the model first.",
+            "``fim`` is not defined on the model provided. "
+            "Please build the model first.",
         ):
             doe_obj.update_FIM_prior(FIM=FIM_update)
 
@@ -331,9 +334,8 @@ def test_reactor_check_measurement_and_output_length_match(self):
 
         with self.assertRaisesRegex(
             ValueError,
-            "Number of experiment outputs, {}, and length of measurement error, {}, do not match. Please check model labeling.".format(
-                27, 1
-            ),
+            "Number of experiment outputs, {}, and length of measurement error, "
+            "{}, do not match. Please check model labeling.".format(27, 1),
         ):
             doe_obj.create_doe_model()
 
@@ -373,7 +375,8 @@ def test_reactor_premature_figure_drawing(self):
 
         with self.assertRaisesRegex(
             RuntimeError,
-            "Results must be provided or the compute_FIM_full_factorial function must be run.",
+            "Results must be provided "
+            "or the compute_FIM_full_factorial function must be run.",
         ):
             doe_obj.draw_factorial_figure()
 
@@ -397,7 +400,8 @@ def test_reactor_figure_drawing_no_des_var_names(self):
 
         with self.assertRaisesRegex(
             ValueError,
-            "If results object is provided, you must include all the design variable names.",
+            "If results object is provided, you must "
+            "include all the design variable names.",
         ):
             doe_obj.draw_factorial_figure(results=doe_obj.fim_factorial_results)
 
@@ -494,7 +498,8 @@ def test_reactor_figure_drawing_bad_sens_names(self):
 
         with self.assertRaisesRegex(
             ValueError,
-            "Sensitivity design variables do not all appear in the results object keys.",
+            "Sensitivity design variables do not all appear "
+            "in the results object keys.",
         ):
             doe_obj.draw_factorial_figure(
                 sensitivity_design_variables={"bad": "entry"},
@@ -516,7 +521,8 @@ def test_reactor_check_get_FIM_without_FIM(self):
 
         with self.assertRaisesRegex(
             RuntimeError,
-            "Model provided does not have variable `fim`. Please make sure the model is built properly before calling `get_FIM`",
+            "Model provided does not have variable `fim`. Please make sure "
+            "the model is built properly before calling `get_FIM`",
         ):
             doe_obj.get_FIM()
 
@@ -535,7 +541,9 @@ def test_reactor_check_get_sens_mat_without_model(self):
 
         with self.assertRaisesRegex(
             RuntimeError,
-            "Model provided does not have variable `sensitivity_jacobian`. Please make sure the model is built properly before calling `get_sensitivity_matrix`",
+            "Model provided does not have variable `sensitivity_jacobian`. "
+            "Please make sure the model is built properly before calling "
+            "`get_sensitivity_matrix`",
         ):
             doe_obj.get_sensitivity_matrix()
 
@@ -554,7 +562,9 @@ def test_reactor_check_get_exp_inputs_without_model(self):
 
         with self.assertRaisesRegex(
             RuntimeError,
-            "Model provided does not have expected structure. Please make sure model is built properly before calling `get_experiment_input_values`",
+            "Model provided does not have expected structure. "
+            "Please make sure model is built properly before "
+            "calling `get_experiment_input_values`",
         ):
             doe_obj.get_experiment_input_values()
 
@@ -573,7 +583,9 @@ def test_reactor_check_get_exp_outputs_without_model(self):
 
         with self.assertRaisesRegex(
             RuntimeError,
-            "Model provided does not have expected structure. Please make sure model is built properly before calling `get_experiment_output_values`",
+            "Model provided does not have expected structure. Please make "
+            "sure model is built properly before calling "
+            "`get_experiment_output_values`",
         ):
             doe_obj.get_experiment_output_values()
 
@@ -592,7 +604,9 @@ def test_reactor_check_get_unknown_params_without_model(self):
 
         with self.assertRaisesRegex(
             RuntimeError,
-            "Model provided does not have expected structure. Please make sure model is built properly before calling `get_unknown_parameter_values`",
+            "Model provided does not have expected structure. Please make "
+            "sure model is built properly before calling "
+            "`get_unknown_parameter_values`",
         ):
             doe_obj.get_unknown_parameter_values()
 
@@ -611,7 +625,9 @@ def test_reactor_check_get_meas_error_without_model(self):
 
         with self.assertRaisesRegex(
             RuntimeError,
-            "Model provided does not have expected structure. Please make sure model is built properly before calling `get_measurement_error_values`",
+            "Model provided does not have expected structure. Please make "
+            "sure model is built properly before calling "
+            "`get_measurement_error_values`",
         ):
             doe_obj.get_measurement_error_values()
 
@@ -685,7 +701,8 @@ def test_bad_FD_generate_scens(self):
 
         with self.assertRaisesRegex(
             AttributeError,
-            "Finite difference option not recognized. Please contact the developers as you should not see this error.",
+            "Finite difference option not recognized. Please "
+            "contact the developers as you should not see this error.",
         ):
             doe_obj.fd_formula = "bad things"
             doe_obj._generate_scenario_blocks()
@@ -706,7 +723,8 @@ def test_bad_FD_seq_compute_FIM(self):
 
         with self.assertRaisesRegex(
             AttributeError,
-            "Finite difference option not recognized. Please contact the developers as you should not see this error.",
+            "Finite difference option not recognized. Please "
+            "contact the developers as you should not see this error.",
         ):
             doe_obj.fd_formula = "bad things"
             doe_obj.compute_FIM(method="sequential")
@@ -726,7 +744,8 @@ def test_bad_objective(self):
 
         with self.assertRaisesRegex(
             AttributeError,
-            "Objective option not recognized. Please contact the developers as you should not see this error.",
+            "Objective option not recognized. Please "
+            "contact the developers as you should not see this error.",
         ):
             doe_obj.objective_option = "bad things"
             doe_obj.create_objective_function()
@@ -746,7 +765,8 @@ def test_no_model_for_objective(self):
 
         with self.assertRaisesRegex(
             RuntimeError,
-            "Model provided does not have variable `fim`. Please make sure the model is built properly before creating the objective.",
+            "Model provided does not have variable `fim`. Please make "
+            "sure the model is built properly before creating the objective.",
         ):
             doe_obj.create_objective_function()
 

From 4e1ba4dfdd14d5fe97c6d48eb8e574202c9f36a1 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Wed, 11 Jun 2025 10:09:59 -0400
Subject: [PATCH 133/143] Fixed test doe solve to be 88 per line

---
 pyomo/contrib/doe/tests/test_doe_solve.py | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/pyomo/contrib/doe/tests/test_doe_solve.py b/pyomo/contrib/doe/tests/test_doe_solve.py
index f4fd72045c4..0391ce8da3d 100644
--- a/pyomo/contrib/doe/tests/test_doe_solve.py
+++ b/pyomo/contrib/doe/tests/test_doe_solve.py
@@ -258,7 +258,8 @@ def test_reactor_obj_cholesky_solve_bad_prior(self):
         DoE_args = get_standard_args(experiment, fd_method, obj_used)
 
         # Specify a prior that is slightly negative definite
-        # Because it is less than the tolerance, it should be adjusted to be positive definite
+        # Because it is less than the tolerance, it should be
+        # adjusted to be positive definite
         # No error should be thrown
         DoE_args['prior_FIM'] = -(_SMALL_TOLERANCE_DEFINITENESS / 100) * np.eye(4)
 
@@ -355,7 +356,8 @@ def test_reactor_grid_search(self):
             design_ranges=design_ranges, method="sequential"
         )
 
-        # Check to make sure the lengths of the inputs in results object are indeed correct
+        # Check to make sure the lengths of the inputs
+        # in results object are indeed correct
         CA_vals = doe_obj.fim_factorial_results["CA[0]"]
         T_vals = doe_obj.fim_factorial_results["T[0]"]
 
@@ -422,7 +424,8 @@ def test_reactor_solve_bad_model(self):
 
         with self.assertRaisesRegex(
             RuntimeError,
-            "Model from experiment did not solve appropriately. Make sure the model is well-posed.",
+            "Model from experiment did not solve appropriately. "
+            "Make sure the model is well-posed.",
         ):
             doe_obj.run_doe()
 

From cc35e84efb9a5f7fb51121e05ccac9934fff5303 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Wed, 11 Jun 2025 10:13:17 -0400
Subject: [PATCH 134/143] Fixed test_doe_build 88 per line

---
 pyomo/contrib/doe/tests/test_doe_build.py | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/pyomo/contrib/doe/tests/test_doe_build.py b/pyomo/contrib/doe/tests/test_doe_build.py
index e3eac842b22..a3e3a71df37 100644
--- a/pyomo/contrib/doe/tests/test_doe_build.py
+++ b/pyomo/contrib/doe/tests/test_doe_build.py
@@ -277,7 +277,8 @@ def test_reactor_fd_central_design_fixing(self):
             # Ensure that each set of constraints has all blocks pairs with scenario 0
             # i.e., (0, 1), (0, 2), ..., (0, N) --> N - 1 constraints
             self.assertEqual(len(getattr(model, con_name)), (len(model.scenarios) - 1))
-            # Should not have any constraints sets beyond the length of design_vars - 1 (started with index 0)
+            # Should not have any constraints sets beyond the
+            # length of design_vars - 1 (started with index 0)
         self.assertFalse(hasattr(model, con_name_base + str(len(design_vars))))
 
     def test_reactor_fd_backward_design_fixing(self):
@@ -309,7 +310,8 @@ def test_reactor_fd_backward_design_fixing(self):
             # Ensure that each set of constraints has all blocks pairs with scenario 0
             # i.e., (0, 1), (0, 2), ..., (0, N) --> N - 1 constraints
             self.assertEqual(len(getattr(model, con_name)), (len(model.scenarios) - 1))
-            # Should not have any constraints sets beyond the length of design_vars - 1 (started with index 0)
+            # Should not have any constraints sets beyond the
+            # length of design_vars - 1 (started with index 0)
         self.assertFalse(hasattr(model, con_name_base + str(len(design_vars))))
 
     def test_reactor_fd_forward_design_fixing(self):
@@ -341,7 +343,8 @@ def test_reactor_fd_forward_design_fixing(self):
             # Ensure that each set of constraints has all blocks pairs with scenario 0
             # i.e., (0, 1), (0, 2), ..., (0, N) --> N - 1 constraints
             self.assertEqual(len(getattr(model, con_name)), (len(model.scenarios) - 1))
-            # Should not have any constraints sets beyond the length of design_vars - 1 (started with index 0)
+            # Should not have any constraints sets beyond the
+            # length of design_vars - 1 (started with index 0)
         self.assertFalse(hasattr(model, con_name_base + str(len(design_vars))))
 
     def test_reactor_check_user_initialization(self):

From 9273fff28fc3a728afc712c549a27e2f632d1e5a Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Wed, 25 Jun 2025 16:04:00 -0400
Subject: [PATCH 135/143] Reverting some changes

---
 pyomo/contrib/doe/examples/reactor_example.py | 44 +++++++++----------
 .../doe/examples/reactor_experiment.py        |  4 +-
 pyomo/contrib/doe/examples/result.json        |  2 +-
 3 files changed, 25 insertions(+), 25 deletions(-)

diff --git a/pyomo/contrib/doe/examples/reactor_example.py b/pyomo/contrib/doe/examples/reactor_example.py
index 91bbd5bc90c..0fe81c723dd 100644
--- a/pyomo/contrib/doe/examples/reactor_example.py
+++ b/pyomo/contrib/doe/examples/reactor_example.py
@@ -61,7 +61,7 @@ def run_reactor_doe():
         fim_initial=None,
         L_diagonal_lower_bound=1e-7,
         solver=None,
-        tee=True,
+        tee=False,
         get_labeled_model_args=None,
         _Cholesky_option=True,
         _only_compute_fim_lower=True,
@@ -71,27 +71,27 @@ def run_reactor_doe():
     design_ranges = {"CA[0]": [1, 5, 9], "T[0]": [300, 700, 9]}
 
     # Compute the full factorial design with the sequential FIM calculation
-    # doe_obj.compute_FIM_full_factorial(design_ranges=design_ranges, method="sequential")
-
-    # # Plot the results
-    # doe_obj.draw_factorial_figure(
-    #     sensitivity_design_variables=["CA[0]", "T[0]"],
-    #     fixed_design_variables={
-    #         "T[0.125]": 300,
-    #         "T[0.25]": 300,
-    #         "T[0.375]": 300,
-    #         "T[0.5]": 300,
-    #         "T[0.625]": 300,
-    #         "T[0.75]": 300,
-    #         "T[0.875]": 300,
-    #         "T[1]": 300,
-    #     },
-    #     title_text="Reactor Example",
-    #     xlabel_text="Concentration of A (M)",
-    #     ylabel_text="Initial Temperature (K)",
-    #     figure_file_name="example_reactor_compute_FIM",
-    #     log_scale=False,
-    # )
+    doe_obj.compute_FIM_full_factorial(design_ranges=design_ranges, method="sequential")
+
+    # Plot the results
+    doe_obj.draw_factorial_figure(
+        sensitivity_design_variables=["CA[0]", "T[0]"],
+        fixed_design_variables={
+            "T[0.125]": 300,
+            "T[0.25]": 300,
+            "T[0.375]": 300,
+            "T[0.5]": 300,
+            "T[0.625]": 300,
+            "T[0.75]": 300,
+            "T[0.875]": 300,
+            "T[1]": 300,
+        },
+        title_text="Reactor Example",
+        xlabel_text="Concentration of A (M)",
+        ylabel_text="Initial Temperature (K)",
+        figure_file_name="example_reactor_compute_FIM",
+        log_scale=False,
+    )
 
     ###########################
     # End sensitivity analysis
diff --git a/pyomo/contrib/doe/examples/reactor_experiment.py b/pyomo/contrib/doe/examples/reactor_experiment.py
index 58643ea07cf..7370244c31c 100644
--- a/pyomo/contrib/doe/examples/reactor_experiment.py
+++ b/pyomo/contrib/doe/examples/reactor_experiment.py
@@ -204,8 +204,8 @@ def label_experiment(self):
         # Add experimental input label for initial concentration
         m.experiment_inputs[m.CA[m.t.first()]] = None
         # Add experimental input label for Temperature
-        m.experiment_inputs[m.T[m.t.first()]] = None
-        # m.experiment_inputs.update((m.T[t], None) for t in m.t_control)
+        # m.experiment_inputs[m.T[m.t.first()]] = None
+        m.experiment_inputs.update((m.T[t], None) for t in m.t_control)
 
         # Add unknown parameter labels
         m.unknown_parameters = pyo.Suffix(direction=pyo.Suffix.LOCAL)
diff --git a/pyomo/contrib/doe/examples/result.json b/pyomo/contrib/doe/examples/result.json
index 8387b7524d8..23b3a05a10d 100644
--- a/pyomo/contrib/doe/examples/result.json
+++ b/pyomo/contrib/doe/examples/result.json
@@ -1 +1 @@
-{"CA0": 5.0, "CA_bounds": [1.0, 5.0], "CB0": 0.0, "CC0": 0.0, "t_range": [0, 1], "control_points": {"0": 481.5, "0.125": 300, "0.25": 300, "0.375": 300, "0.5": 300, "0.625": 300, "0.75": 300, "0.875": 300, "1": 300}, "T_bounds": [300, 700], "A1": 84.79, "A2": 371.72, "E1": 7.78, "E2": 15.05}
+{"CA0": 5.0, "CA_bounds": [1.0, 5.0], "CB0": 0.0, "CC0": 0.0, "t_range": [0, 1], "control_points": {"0": 500, "0.125": 300, "0.25": 300, "0.375": 300, "0.5": 300, "0.625": 300, "0.75": 300, "0.875": 300, "1": 300}, "T_bounds": [300, 700], "A1": 84.79, "A2": 371.72, "E1": 7.78, "E2": 15.05}

From 4674f3441c1a74c45eb1e6ee8d4b9c2ae9b917c0 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 26 Jun 2025 15:34:55 -0400
Subject: [PATCH 136/143] Fix copyright year.

---
 pyomo/contrib/doe/grey_box_utilities.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index 98ea3c3c093..f669bf48721 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -1,7 +1,7 @@
 #  ___________________________________________________________________________
 #
 #  Pyomo: Python Optimization Modeling Objects
-#  Copyright (c) 2008-2024
+#  Copyright (c) 2008-2025
 #  National Technology and Engineering Solutions of Sandia, LLC
 #  Under the terms of Contract DE-NA0003525 with National Technology and
 #  Engineering Solutions of Sandia, LLC, the U.S. Government retains certain

From 8881cfb27412c94b0e9287568fa15512e3079a25 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 26 Jun 2025 15:35:14 -0400
Subject: [PATCH 137/143] Remove old code

---
 pyomo/contrib/doe/doe.py | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index d95b70fc86b..01485a1f5d5 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -365,11 +365,6 @@ def run_doe(self, model=None, results_file=None):
                         model.obj_cons.egb_fim_block.inputs[(j, i)].set_value(
                             pyo.value(model.fim[(i, j)])
                         )
-                    else:  # REMOVE THIS IF USING LOWER TRIANGLE
-                        pass
-                        # model.obj_cons.egb_fim_block.inputs[(j, i)].set_value(
-                        #    pyo.value(model.fim[(j, i)])
-                        # )
             # Set objective value
             if self.objective_option == ObjectiveLib.trace:
                 # Do safe inverse here?

From 4684c5efbb57ba307e1f8e31dce4577c754b370a Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 26 Jun 2025 15:37:29 -0400
Subject: [PATCH 138/143] TODO vs ToDo nit solved.

---
 pyomo/contrib/doe/doe.py | 25 ++++++++++++-------------
 1 file changed, 12 insertions(+), 13 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index 01485a1f5d5..47ca648db87 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -228,7 +228,6 @@ def __init__(
         self.tee = tee
         self.grey_box_tee = grey_box_tee
 
-        # ToDo: allow user to supply grey box solver
         if grey_box_solver:
             self.grey_box_solver = grey_box_solver
         else:
@@ -299,7 +298,7 @@ def run_doe(self, model=None, results_file=None):
             # model.add_component(doe_block_name, doe_block)
             pass
 
-        # ToDo: potentially work with this for more complicated models
+        # TODO: potentially work with this for more complicated models
         # Create the full DoE model (build scenarios for F.D. scheme)
         if not self._built_scenarios:
             self.create_doe_model(model=model)
@@ -506,8 +505,8 @@ def run_doe(self, model=None, results_file=None):
         self.results["Finite Difference Step"] = self.step
         self.results["Nominal Parameter Scaling"] = self.scale_nominal_param_value
 
-        # ToDo: Add more useful fields to the results object?
-        # ToDo: Add MetaData from the user to the results object? Or leave to the user?
+        # TODO: Add more useful fields to the results object?
+        # TODO: Add MetaData from the user to the results object? Or leave to the user?
 
         # If the user specifies to save the file, do it here as a json
         if results_file is not None:
@@ -733,7 +732,7 @@ def _sequential_FIM(self, model=None):
             # Increment the count
             i += 1
 
-        # ToDo: As more complex measurement error schemes
+        # TODO: As more complex measurement error schemes
         #       are put in place, this needs to change
         # Add independent (non-correlated) measurement
         # error for FIM calculation
@@ -834,7 +833,7 @@ def _kaug_FIM(self, model=None):
             cov_y[count, count] = 1 / v
             count += 1
 
-        # ToDo: need to add a covariance matrix for measurements (sigma inverse)
+        # TODO: need to add a covariance matrix for measurements (sigma inverse)
         # i.e., cov_y = self.cov_y or model.cov_y
         # Still deciding where this would be best.
 
@@ -1438,7 +1437,7 @@ def create_grey_box_objective_function(self, model=None):
         if model is None:
             model = model = self.model
 
-        # ToDo: Make this naming convention robust
+        # TODO: Make this naming convention robust
         model.obj_cons = pyo.Block()
 
         # Create FIM External Grey Box object
@@ -1707,8 +1706,8 @@ def compute_FIM_full_factorial(
                 "Design ranges keys must be a subset of experimental design names."
             )
 
-        # ToDo: Add more objective types? i.e., modified-E; G-opt; V-opt; etc?
-        # ToDo: Also, make this a result object, or more user friendly.
+        # TODO: Add more objective types? i.e., modified-E; G-opt; V-opt; etc?
+        # TODO: Also, make this a result object, or more user friendly.
         fim_factorial_results = {k.name: [] for k, v in model.experiment_inputs.items()}
         fim_factorial_results.update(
             {
@@ -1882,7 +1881,7 @@ def draw_factorial_figure(
         des_names = full_design_variable_names
 
         # Inputs must exist for the function to do anything
-        # ToDo: Put in a default value function?????
+        # TODO: Put in a default value function?????
         if sensitivity_design_variables is None:
             raise ValueError("``sensitivity_design_variables`` must be included.")
 
@@ -1908,7 +1907,7 @@ def draw_factorial_figure(
                 "in the results object keys."
             )
 
-        # ToDo: Make it possible to plot pair-wise sensitivities for all variables
+        # TODO: Make it possible to plot pair-wise sensitivities for all variables
         #       e.g. a curve like low-dimensional posterior distributions
         if len(sensitivity_design_variables) > 2:
             raise NotImplementedError(
@@ -1976,7 +1975,7 @@ def draw_factorial_figure(
                 log_scale=log_scale,
                 figure_file_name=figure_file_name,
             )
-        # ToDo: Add the multidimensional plotting
+        # TODO: Add the multidimensional plotting
         else:
             pass
 
@@ -2479,7 +2478,7 @@ def get_experiment_output_values(self, model=None):
 
         return y_hat_vals
 
-    # ToDo: For more complicated error structures, this should become
+    # TODO: For more complicated error structures, this should become
     #       get cov_y, or so, and this method will be deprecated
     # Gets the measurement error values from an existing model
     def get_measurement_error_values(self, model=None):

From 94b6589b5e57a4508808fe353d36113a0bf82e68 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 26 Jun 2025 15:38:36 -0400
Subject: [PATCH 139/143] Remove old bug testing line

---
 pyomo/contrib/doe/examples/reactor_experiment.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/pyomo/contrib/doe/examples/reactor_experiment.py b/pyomo/contrib/doe/examples/reactor_experiment.py
index 7370244c31c..6ef32af3d28 100644
--- a/pyomo/contrib/doe/examples/reactor_experiment.py
+++ b/pyomo/contrib/doe/examples/reactor_experiment.py
@@ -204,7 +204,6 @@ def label_experiment(self):
         # Add experimental input label for initial concentration
         m.experiment_inputs[m.CA[m.t.first()]] = None
         # Add experimental input label for Temperature
-        # m.experiment_inputs[m.T[m.t.first()]] = None
         m.experiment_inputs.update((m.T[t], None) for t in m.t_control)
 
         # Add unknown parameter labels

From d7b642dd4460872d0a93662518a9ee957dd666ff Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Thu, 26 Jun 2025 15:45:24 -0400
Subject: [PATCH 140/143] Updated TODO in this file as well.

---
 pyomo/contrib/doe/grey_box_utilities.py | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/pyomo/contrib/doe/grey_box_utilities.py b/pyomo/contrib/doe/grey_box_utilities.py
index f669bf48721..771f1ae230b 100644
--- a/pyomo/contrib/doe/grey_box_utilities.py
+++ b/pyomo/contrib/doe/grey_box_utilities.py
@@ -133,11 +133,11 @@ def input_names(self):
         return input_names_list
 
     def equality_constraint_names(self):
-        # ToDo: Are there any objectives that will have constraints?
+        # TODO: Are there any objectives that will have constraints?
         return []
 
     def output_names(self):
-        # ToDo: add output name for the variable. This may have to be
+        # TODO: add output name for the variable. This may have to be
         # an input from the user. Or it could depend on the usage of
         # the ObjectiveLib Enum object, which should have an associated
         # name for the objective function at all times.
@@ -160,7 +160,7 @@ def set_input_values(self, input_values):
         np.copyto(self._input_values, input_values)
 
     def evaluate_equality_constraints(self):
-        # ToDo: are there any objectives that will have constraints?
+        # TODO: are there any objectives that will have constraints?
         return None
 
     def evaluate_outputs(self):
@@ -220,7 +220,7 @@ def finalize_block_construction(self, pyomo_block):
             pyomo_block.outputs["ME-opt"] = output_value
 
     def evaluate_jacobian_equality_constraints(self):
-        # ToDo: Do any objectives require constraints?
+        # TODO: Do any objectives require constraints?
 
         # Returns coo_matrix of the correct shape
         return None
@@ -235,7 +235,7 @@ def evaluate_jacobian_outputs(self):
             self._n_params, self._n_params
         )
 
-        # ToDo: Add inertia correction for
+        # TODO: Add inertia correction for
         #       negative/small eigenvalues
         eig_vals, eig_vecs = np.linalg.eig(M)
         if min(eig_vals) <= 1e-3:
@@ -323,14 +323,14 @@ def evaluate_jacobian_outputs(self):
 
     # Beyond here is for Hessian information
     def set_equality_constraint_multipliers(self, eq_con_multiplier_values):
-        # ToDo: Do any objectives require constraints?
+        # TODO: Do any objectives require constraints?
         # Assert lengths match
         self._eq_con_mult_values = np.asarray(
             eq_con_multiplier_values, dtype=np.float64
         )
 
     def set_output_constraint_multipliers(self, output_con_multiplier_values):
-        # ToDo: Do any objectives require constraints?
+        # TODO: Do any objectives require constraints?
         # Assert length matches
         self._output_con_mult_values = np.asarray(
             output_con_multiplier_values, dtype=np.float64
@@ -342,7 +342,7 @@ def evaluate_hessian_equality_constraints(self):
         return None
 
     def evaluate_hessian_outputs(self, FIM=None):
-        # ToDo: significant bookkeeping if the hessian's require vectorized
+        # TODO: significant bookkeeping if the hessian's require vectorized
         # operations. Just need mapping that works well and we are good.
         current_FIM = self._get_FIM()
 

From 4e445eced03ec76e878c3502529d6177b44ddc67 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Tue, 15 Jul 2025 09:09:47 -0400
Subject: [PATCH 141/143] Updated attribute errors to Dev errors

---
 pyomo/contrib/doe/doe.py                   | 11 +++----
 pyomo/contrib/doe/tests/test_doe_errors.py | 34 ++++++++++++++++------
 2 files changed, 31 insertions(+), 14 deletions(-)

diff --git a/pyomo/contrib/doe/doe.py b/pyomo/contrib/doe/doe.py
index 47ca648db87..99ecddb47b0 100644
--- a/pyomo/contrib/doe/doe.py
+++ b/pyomo/contrib/doe/doe.py
@@ -40,7 +40,8 @@
     matplotlib as plt,
     scipy_available,
 )
-from pyomo.common.modeling import unique_component_name
+
+from pyomo.common.errors import DeveloperError
 from pyomo.common.timing import TicTocTimer
 
 from pyomo.contrib.sensitivity_toolbox.sens import get_dsdp
@@ -628,7 +629,7 @@ def _sequential_FIM(self, model=None):
             )
             model.scenarios = range(len(model.unknown_parameters) + 1)
         else:
-            raise AttributeError(
+            raise DeveloperError(
                 "Finite difference option not recognized. Please "
                 "contact the developers as you should not see this error."
             )
@@ -927,7 +928,7 @@ def initialize_jac(m, i, j):
                 return dict_jac_initialize[(i, j)]
             # Otherwise initialize to 0.1 (which is an arbitrary non-zero value)
             else:
-                raise AttributeError(
+                raise DeveloperError(
                     "Jacobian being initialized when the jac_initial attribute "
                     "is None. Please contact the developers as you should not "
                     "see this error."
@@ -1170,7 +1171,7 @@ def _generate_scenario_blocks(self, model=None):
             )
             model.scenarios = range(len(model.base_model.unknown_parameters) + 1)
         else:
-            raise AttributeError(
+            raise DeveloperError(
                 "Finite difference option not recognized. Please contact "
                 "the developers as you should not see this error."
             )
@@ -1290,7 +1291,7 @@ def create_objective_function(self, model=None):
             ObjectiveLib.trace,
             ObjectiveLib.zero,
         ]:
-            raise AttributeError(
+            raise DeveloperError(
                 "Objective option not recognized. Please contact the "
                 "developers as you should not see this error."
             )
diff --git a/pyomo/contrib/doe/tests/test_doe_errors.py b/pyomo/contrib/doe/tests/test_doe_errors.py
index 29f9b5f2644..7f36f3d037d 100644
--- a/pyomo/contrib/doe/tests/test_doe_errors.py
+++ b/pyomo/contrib/doe/tests/test_doe_errors.py
@@ -19,6 +19,7 @@
     scipy_available,
 )
 
+from pyomo.common.errors import DeveloperError
 from pyomo.common.fileutils import this_file_dir
 import pyomo.common.unittest as unittest
 
@@ -700,9 +701,14 @@ def test_bad_FD_generate_scens(self):
         doe_obj = DesignOfExperiments(**DoE_args)
 
         with self.assertRaisesRegex(
-            AttributeError,
-            "Finite difference option not recognized. Please "
-            "contact the developers as you should not see this error.",
+            DeveloperError,
+            "Internal Pyomo implementation error:\n"
+            "        "
+            "'Finite difference option not recognized. Please contact the\n"
+            "        "
+            "developers as you should not see this error.'\n"
+            "    "
+            "Please report this to the Pyomo Developers.",
         ):
             doe_obj.fd_formula = "bad things"
             doe_obj._generate_scenario_blocks()
@@ -722,9 +728,14 @@ def test_bad_FD_seq_compute_FIM(self):
         doe_obj = DesignOfExperiments(**DoE_args)
 
         with self.assertRaisesRegex(
-            AttributeError,
-            "Finite difference option not recognized. Please "
-            "contact the developers as you should not see this error.",
+            DeveloperError,
+            "Internal Pyomo implementation error:\n"
+            "        "
+            "'Finite difference option not recognized. Please contact the\n"
+            "        "
+            "developers as you should not see this error.'\n"
+            "    "
+            "Please report this to the Pyomo Developers.",
         ):
             doe_obj.fd_formula = "bad things"
             doe_obj.compute_FIM(method="sequential")
@@ -743,9 +754,14 @@ def test_bad_objective(self):
         doe_obj = DesignOfExperiments(**DoE_args)
 
         with self.assertRaisesRegex(
-            AttributeError,
-            "Objective option not recognized. Please "
-            "contact the developers as you should not see this error.",
+            DeveloperError,
+            "Internal Pyomo implementation error:\n"
+            "        "
+            "'Objective option not recognized. Please contact the developers as\n"
+            "        "
+            "you should not see this error.'\n"
+            "    "
+            "Please report this to the Pyomo Developers.",
         ):
             doe_obj.objective_option = "bad things"
             doe_obj.create_objective_function()

From 89813caf398e3887e2126d667d8ccedf3473bc3a Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Tue, 15 Jul 2025 09:11:19 -0400
Subject: [PATCH 142/143] Typo fix by @mrmundt

Co-authored-by: Miranda Mundt <55767766+mrmundt@users.noreply.github.com>
---
 pyomo/contrib/doe/tests/test_greybox.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 38cb209960f..848a39950ff 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -329,7 +329,7 @@ def make_greybox_and_doe_objects_rooney_biegler(objective_option):
 
 # Test whether or not cyipopt
 # is appropriately calling the
-# lienar solvers.
+# linear solvers.
 bad_message = "Invalid option encountered."
 cyipopt_call_working = True
 if numpy_available and scipy_available and ipopt_available and cyipopt_available:

From 2ae40046ffaa6caae8b8ad6cae5844a656bdf1f2 Mon Sep 17 00:00:00 2001
From: Daniel Laky <29078718+djlaky@users.noreply.github.com>
Date: Tue, 15 Jul 2025 09:14:54 -0400
Subject: [PATCH 143/143] Removed old code, add verbose comment

---
 pyomo/contrib/doe/tests/test_greybox.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py
index 848a39950ff..f2dded77b33 100644
--- a/pyomo/contrib/doe/tests/test_greybox.py
+++ b/pyomo/contrib/doe/tests/test_greybox.py
@@ -342,9 +342,8 @@ def make_greybox_and_doe_objects_rooney_biegler(objective_option):
         # Use the grey box objective
         doe_object.use_grey_box = True
 
-        # Change linear solvers to mumps
-        # doe_object.solver.options["linear_solver"] = "mumps"
-        # doe_object.grey_box_solver.config.options["linear_solver"] = "mumps"
+        # Run for 1 iteration to see if
+        # cyipopt was called.
         doe_object.grey_box_solver.config.options["max_iter"] = 1
 
         doe_object.run_doe()