Add support for Greybox model DOF counitng in degrees_of_freedom function

idaes/core/util/model_statistics.py

@@ -25,6 +25,7 @@
 from pyomo.core.expr import identify_variables
 from pyomo.common.collections import ComponentSet
 from pyomo.common.deprecation import deprecation_warning
+from pyomo.contrib.pynumero.interfaces.external_grey_box import ExternalGreyBoxBlock
 
 import idaes.logger as idaeslog
 
@@ -377,7 +378,31 @@ def number_activated_equalities(block):
     Returns:
         Number of activated equality Constraint components in block
     """
-    return sum(1 for _ in activated_equalities_generator(block))
+    return sum(
+        1 for _ in activated_equalities_generator(block)
+    ) + number_grey_box_equalities(block)
+
+
+def number_grey_box_equalities(block):
+    """
+    Method to return the number of equality constraints in GreyBox
+    A GreyBox model is always assumed to be 0DOFs where each output[i]==f(inputs)
+    where f is GreyBox model, this should be true regardless if
+    GreyBox model is doing internal optimization or not, as every output
+    is calculated through a the GreyBox internal model using provided inputs.
+
+    Args:
+        block : model to be studied
+
+    Returns:
+        Number of activated equality Constraint components in block
+    """
+    equalities = 0
+    for grey_box in _iter_indexed_block_data_objects(
+        block, ctype=ExternalGreyBoxBlock, active=True, descend_into=True
+    ):
+        equalities += len(grey_box.outputs)
+    return equalities
 
 
 def deactivated_equalities_generator(block):
@@ -529,7 +554,7 @@ def deactivated_inequalities_generator(block):
         block : model to be studied
 
     Returns:
-        A generator which returns all indeactivated equality Constraint
+        A generator which returns all in deactivated equality Constraint
         components block
     """
     for c in total_inequalities_generator(block):
@@ -1034,6 +1059,19 @@ def unfixed_variables_in_activated_equalities_set(block):
     for v in variables_in_activated_equalities_set(block):
         if not v.fixed:
             var_set.add(v)
+
+    # Checks for greyboxes, and if they exist will add
+    # input and output vars to var_set if they are free
+    # inputs and outputs are defined names for greybox class and should always exist
+    for grey_box in _iter_indexed_block_data_objects(
+        block, ctype=ExternalGreyBoxBlock, active=True, descend_into=True
+    ):
+        for in_var in grey_box.inputs:
+            if not grey_box.inputs[in_var].fixed:
+                var_set.add(grey_box.inputs[in_var])
+        for out_var in grey_box.outputs:
+            if not grey_box.outputs[out_var].fixed:
+                var_set.add(grey_box.outputs[out_var])
     return var_set
 
 

idaes/core/util/tests/test_model_statistics.py

@@ -31,6 +31,10 @@
 
 from idaes.core.util.model_statistics import *
 from idaes.core.util.model_statistics import _iter_indexed_block_data_objects
+from pyomo.contrib.pynumero.interfaces.external_grey_box import (
+    ExternalGreyBoxBlock,
+    ExternalGreyBoxModel,
+)
 
 
 @pytest.mark.unit
@@ -685,6 +689,42 @@ def test_degrees_of_freedom(m):
     assert degrees_of_freedom(m.b2) == -1
 
 
+@pytest.mark.unit
+def test_degrees_of_freedom_with_graybox():
+    """non functional graybox model added to m fixture, to test DOFs
+
+    GreyBoxModel has 3 inputs and 2 outputs calculated an unknown function"""
+
+    class BasicGrayBox(ExternalGreyBoxModel):
+        def input_names(self):
+            return ["a1", "a2", "a3"]
+
+        def output_names(self):
+            return ["o1", "o2"]
+
+    m = ConcreteModel()
+
+    m.gb = ExternalGreyBoxBlock(external_model=BasicGrayBox())
+    # verify DOFS works on stand alone greybox
+    assert degrees_of_freedom(m) == 3
+    m.gb.inputs.fix()
+    assert degrees_of_freedom(m) == 0
+    m.gb.outputs.fix()
+    assert degrees_of_freedom(m) == -2
+    m.gb.outputs.unfix()
+
+    # verify DOFs works on greybox connected to other vars on a model via constraints
+    m.a1 = Var(initialize=1)
+    m.a1.fix()
+    m.gb.inputs["a1"].unfix()
+    m.a1_eq = Constraint(expr=m.a1 == m.gb.inputs["a1"])
+    assert degrees_of_freedom(m) == 0
+    m.o1 = Var(initialize=1)
+    m.o1_eq = Constraint(expr=m.o1 == m.gb.outputs["o1"])
+    m.o1.fix()
+    assert degrees_of_freedom(m) == -1
+
+
 @pytest.mark.unit
 def test_large_residuals_set(m):
     # Initialize derivative var values so no errors occur