merge main in, fix conflicts

backend/app/internal/flowsheet_manager.py

@@ -31,7 +31,7 @@
 
 _log = idaeslog.getLogger(__name__)
 # _log.setLevel(logging.DEBUG)
-VERSION = 2
+VERSION = 3
 
 
 class FlowsheetInfo(BaseModel):

backend/app/internal/parameter_sweep.py

@@ -32,8 +32,8 @@ def set_up_sensitivity(m, solve, output_params):
 
 
 def get_conversion_unit(flowsheet, key):
-    obj = flowsheet.fs_exp.model_objects[key].obj
-    ui_units = flowsheet.fs_exp.model_objects[key].ui_units
+    obj = flowsheet.fs_exp.exports[key].obj
+    ui_units = flowsheet.fs_exp.exports[key].ui_units
     temp = Var(initialize=1, units=obj.get_units())
     temp.construct()
     crv = value(pyunits.convert(temp, to_units=ui_units))
@@ -103,54 +103,54 @@ def run_parameter_sweep(flowsheet, info):
         keys = []
         conversion_factors = []
         results_table = {"headers": []}
-        for key in flowsheet.fs_exp.model_objects:
-            if flowsheet.fs_exp.model_objects[key].is_sweep:
+        for key in flowsheet.fs_exp.exports:
+            if flowsheet.fs_exp.exports[key].is_sweep:
                 if (
-                    flowsheet.fs_exp.model_objects[key].lb is not None
-                    and flowsheet.fs_exp.model_objects[key].ub is not None
+                    flowsheet.fs_exp.exports[key].lb is not None
+                    and flowsheet.fs_exp.exports[key].ub is not None
                 ):
                     results_table["headers"].append(
-                        flowsheet.fs_exp.model_objects[key].name
+                        flowsheet.fs_exp.exports[key].name
                     )
                     conversion_factor = get_conversion_unit(flowsheet, key)
                     try:
                         parameters.append(
                             {
-                                "name": flowsheet.fs_exp.model_objects[key].name,
-                                "lb": flowsheet.fs_exp.model_objects[key].obj.lb,
-                                "ub": flowsheet.fs_exp.model_objects[key].obj.ub,
-                                "num_samples": flowsheet.fs_exp.model_objects[
+                                "name": flowsheet.fs_exp.exports[key].name,
+                                "lb": flowsheet.fs_exp.exports[key].obj.lb,
+                                "ub": flowsheet.fs_exp.exports[key].obj.ub,
+                                "num_samples": flowsheet.fs_exp.exports[
                                     key
                                 ].num_samples,
-                                "param": flowsheet.fs_exp.model_objects[key].obj,
+                                "param": flowsheet.fs_exp.exports[key].obj,
                             }
                         )
                     except:
                         parameters.append(
                             {
-                                "name": flowsheet.fs_exp.model_objects[key].name,
-                                "lb": flowsheet.fs_exp.model_objects[key].obj.lb,
-                                "ub": flowsheet.fs_exp.model_objects[key].obj.ub,
+                                "name": flowsheet.fs_exp.exports[key].name,
+                                "lb": flowsheet.fs_exp.exports[key].obj.lb,
+                                "ub": flowsheet.fs_exp.exports[key].obj.ub,
                                 "num_samples": "5",
-                                "param": flowsheet.fs_exp.model_objects[key].obj,
+                                "param": flowsheet.fs_exp.exports[key].obj,
                             }
                         )
                     # HTTPException(500, detail=f"Sweep failed: {parameters}")
-                    flowsheet.fs_exp.model_objects[key].obj.fix()
+                    flowsheet.fs_exp.exports[key].obj.fix()
                     conversion_factors.append(conversion_factor)
                     keys.append(key)
-        for key in flowsheet.fs_exp.model_objects:
+        for key in flowsheet.fs_exp.exports:
             if (
-                flowsheet.fs_exp.model_objects[key].is_output
+                flowsheet.fs_exp.exports[key].is_output
                 or (
-                    not flowsheet.fs_exp.model_objects[key].is_output
-                    and flowsheet.fs_exp.model_objects[key].is_input
-                    and not flowsheet.fs_exp.model_objects[key].fixed
+                    not flowsheet.fs_exp.exports[key].is_output
+                    and flowsheet.fs_exp.exports[key].is_input
+                    and not flowsheet.fs_exp.exports[key].fixed
                 )
-                # and not flowsheet.fs_exp.model_objects[key].is_input
+                # and not flowsheet.fs_exp.exports[key].is_input
             ):
                 results_table["headers"].append(
-                    flowsheet.fs_exp.model_objects[key].name
+                    flowsheet.fs_exp.exports[key].name
                 )
 
                 try:
@@ -160,8 +160,8 @@ def run_parameter_sweep(flowsheet, info):
                 conversion_factors.append(conversion_factor)
                 output_params.append(
                     {
-                        "name": flowsheet.fs_exp.model_objects[key].name,
-                        "param": flowsheet.fs_exp.model_objects[key].obj,
+                        "name": flowsheet.fs_exp.exports[key].name,
+                        "param": flowsheet.fs_exp.exports[key].obj,
                     }
                 )
                 keys.append(key)

backend/app/routers/flowsheets.py

@@ -210,7 +210,7 @@ async def unbuild_config(flowsheet_id: str):
     fs_exp = flowsheet.fs_exp
     fs_exp.m = None
     fs_exp.obj = None
-    fs_exp.model_objects = {}
+    fs_exp.exports = {}
     fs_exp.dof = 0
     fs_exp.sweep_results = {}
     fs_exp.build_options = {}

backend/tests/app/routers/test_flowsheets.py

@@ -102,7 +102,7 @@ def test_get_config(client, flowsheet_id):
     )
     assert response.status_code == 200, body
     config = body
-    assert len(config["model_objects"]) > 0
+    assert len(config["exports"]) > 0
 
 
 @pytest.mark.unit
@@ -130,18 +130,18 @@ def test_update(client, flowsheet_id):
     response, body = get_flowsheet(client, flowsheet_id, "reset")
     assert response.status_code == 200, body
     new_body = body.copy()
-    for var_name, var_data in new_body["model_objects"].items():
+    for var_name, var_data in new_body["exports"].items():
         value = var_data["value"]
         if isinstance(value, float):
             var_data["value"] += 1
             print(f"changed {var_name}")
     response, update_body = post_flowsheet(client, flowsheet_id, "update", new_body)
     assert response.status_code == 200, update_body
-    for var_name, var_data in update_body["model_objects"].items():
+    for var_name, var_data in update_body["exports"].items():
         value = var_data["value"]
         if isinstance(value, float) and var_data["is_input"] and not var_data["is_readonly"]:
             print(f"check {var_name} is_input={var_data['is_input']}")
-            expect_value = new_body["model_objects"][var_name]["value"]
+            expect_value = new_body["exports"][var_name]["value"]
             assert value == expect_value
 
 
@@ -150,7 +150,7 @@ def test_update_missing(client, flowsheet_id):
     response, body = get_flowsheet(client, flowsheet_id, "reset")
     assert response.status_code == 200, body
     new_body = body.copy()
-    new_body["model_objects"]["missing"] = {
+    new_body["exports"]["missing"] = {
         "name": "Tank 99 inlet flowrate",
         "value": 2.0,
         "display_units": "None",
@@ -191,9 +191,9 @@ def test_load_config(client, flowsheet_id):
     )
     assert response.status_code == 200
     config = body
-    assert len(config["model_objects"]) > 0
+    assert len(config["exports"]) > 0
     # make recognizable values
-    for var_name, var_data in config["model_objects"].items():
+    for var_name, var_data in config["exports"].items():
         var_data["value"] = 99
     response, body = post_flowsheet(
         client, flowsheet_id, "save", config, query_params={"name": "test name!", "version": "1"}
@@ -204,8 +204,8 @@ def test_load_config(client, flowsheet_id):
     )
     assert response.status_code == 200, body
     config2 = body
-    for var_name, var_data in config2["model_objects"].items():
-        assert var_data["value"] == config["model_objects"][var_name]["value"]
+    for var_name, var_data in config2["exports"].items():
+        assert var_data["value"] == config["exports"][var_name]["value"]
 
 
 @pytest.mark.unit

electron/ui/src/components/SweepOutput/SweepOutput.js

@@ -95,9 +95,9 @@ export default function SweepOutput(props) {
                 }
             }
 
-            let xLabel = `${outputData.outputData.sweep_results.headers[xIndex]} (${outputData.outputData.model_objects[keys[xIndex]].display_units})`
-            let yLabel = `${outputData.outputData.sweep_results.headers[yIndex]} (${outputData.outputData.model_objects[keys[yIndex]].display_units})`
-            let zLabel = `${outputData.outputData.sweep_results.headers[zIndex]} (${outputData.outputData.model_objects[keys[zIndex]].display_units})`
+            let xLabel = `${outputData.outputData.sweep_results.headers[xIndex]} (${outputData.outputData.exports[keys[xIndex]].display_units})`
+            let yLabel = `${outputData.outputData.sweep_results.headers[yIndex]} (${outputData.outputData.exports[keys[yIndex]].display_units})`
+            let zLabel = `${outputData.outputData.sweep_results.headers[zIndex]} (${outputData.outputData.exports[keys[zIndex]].display_units})`
 
             let tempPlotData = [{
                 z:z,
@@ -150,7 +150,7 @@ export default function SweepOutput(props) {
             let keyIdx = 1
             for (let each of ys) {
                 if( keyIdx === yIndex){
-                    let yName = `${outputData.outputData.sweep_results.headers[keyIdx]} (${outputData.outputData.model_objects[keys[keyIdx]].display_units})`
+                    let yName = `${outputData.outputData.sweep_results.headers[keyIdx]} (${outputData.outputData.exports[keys[keyIdx]].display_units})`
                     let tempTrace = {x: x, y: each, type:"scatter", name: yName}
                     tempData.push(tempTrace)
 
@@ -159,8 +159,8 @@ export default function SweepOutput(props) {
 
             }
 
-            let xLabel = `${outputData.outputData.sweep_results.headers[0]} (${outputData.outputData.model_objects[keys[0]].display_units})`
-            let yLabel = `${outputData.outputData.sweep_results.headers[yIndex]} (${outputData.outputData.model_objects[keys[yIndex]].display_units})`
+            let xLabel = `${outputData.outputData.sweep_results.headers[0]} (${outputData.outputData.exports[keys[0]].display_units})`
+            let yLabel = `${outputData.outputData.sweep_results.headers[yIndex]} (${outputData.outputData.exports[keys[yIndex]].display_units})`
             let tempLayout = {
                 xaxis: {
                     title: {

electron/ui/src/tests/data/BuildOptionsData.json

@@ -2,7 +2,7 @@
     "inputData": {
         "name": "Magprex",
         "description": "Magprex flowsheet",
-        "model_objects": {},
+        "exports": {},
         "version": 2,
         "requires_idaes_solver": false,
         "dof": 0,

electron/ui/src/views/FlowsheetConfig/ConfigInput/ConfigInput.js

@@ -133,21 +133,21 @@ export default function ConfigInput(props) {
 
     const handleUpdateDisplayValue = (id, value) => {
         let tempFlowsheetData = {...flowsheetData}
-        let previousValue = tempFlowsheetData.inputData.model_objects[id].value
+        let previousValue = tempFlowsheetData.inputData.exports[id].value
         console.log('updating '+id+' with value '+value+'. previous value was '+previousValue)
-        tempFlowsheetData.inputData.model_objects[id].value = value
+        tempFlowsheetData.inputData.exports[id].value = value
     }
 
     const handleUpdateFixed = (id, value, type) => {
         let tempFlowsheetData = {...flowsheetData}
-        tempFlowsheetData.inputData.model_objects[id].fixed = value
+        tempFlowsheetData.inputData.exports[id].fixed = value
         if(type==="sweep") {
-            // flowsheetData.inputData.model_objects[id].is_sweep = true
-            tempFlowsheetData.inputData.model_objects[id].is_sweep = true
+            // flowsheetData.inputData.exports[id].is_sweep = true
+            tempFlowsheetData.inputData.exports[id].is_sweep = true
         }
         else {
-            // flowsheetData.inputData.model_objects[id].is_sweep = false
-            tempFlowsheetData.inputData.model_objects[id].is_sweep = false
+            // flowsheetData.inputData.exports[id].is_sweep = false
+            tempFlowsheetData.inputData.exports[id].is_sweep = false
         }
         updateFlowsheetData(tempFlowsheetData, null)
         runButtonRef.current?.checkDisableRun()
@@ -156,13 +156,13 @@ export default function ConfigInput(props) {
 
     const handleUpdateBounds = (id, value, bound) => {
         let tempFlowsheetData = {...flowsheetData}
-        tempFlowsheetData.inputData.model_objects[id][bound] = value
+        tempFlowsheetData.inputData.exports[id][bound] = value
     }
 
     const handleUpdateSamples = (id, value) => {
         let tempFlowsheetData = {...flowsheetData}
-        tempFlowsheetData.inputData.model_objects[id].num_samples = value
-        console.log('updating samples '+id+' with value '+value+ ' '+tempFlowsheetData.inputData.model_objects[id].num_samples)
+        tempFlowsheetData.inputData.exports[id].num_samples = value
+        console.log('updating samples '+id+' with value '+value+ ' '+tempFlowsheetData.inputData.exports[id].num_samples)
     }
     /**
      * Organize variables into sections by their 'category' attribute.
@@ -233,7 +233,7 @@ export default function ConfigInput(props) {
     const renderInputAccordions = () => {
         try {
             if(Object.keys(displayData).length > 0) {
-                let var_sections = organizeVariables(displayData.model_objects)
+                let var_sections = organizeVariables(displayData.exports)
                 return Object.entries(var_sections).map(([key, value])=>{
                     let _key = key + Math.floor(Math.random() * 100001);
                     if(Object.keys(value.input_variables).length > 0) {
@@ -390,8 +390,8 @@ const RunButton = forwardRef(({ ...props }, ref) => {
         if (solveType === "solve") setDisableRun(false)
         else {
             let tempDisableRun = true
-            for(let each of Object.keys(flowsheetData.inputData.model_objects)) {
-                let modelObject = flowsheetData.inputData.model_objects[each]
+            for(let each of Object.keys(flowsheetData.inputData.exports)) {
+                let modelObject = flowsheetData.inputData.exports[each]
                 if(modelObject.is_sweep) {
                     tempDisableRun = false
                     break

electron/ui/src/views/FlowsheetConfig/ConfigOutput/ConfigOutput.js

@@ -57,8 +57,8 @@ export default function ConfigOutput(props) {
     const handleDownloadOutput = () => {
         let headers = ['category','metric','units','value']
         let values = []
-        for (let key of Object.keys(outputData.outputData.model_objects)) {
-            let each = outputData.outputData.model_objects[key]
+        for (let key of Object.keys(outputData.outputData.exports)) {
+            let each = outputData.outputData.exports[key]
             if (each.is_output) {
                 values.push([each.output_category, each.name, each.display_units, each.value])
             }
@@ -152,7 +152,7 @@ export default function ConfigOutput(props) {
 
 
     const renderOutputAccordions = () => { 
-        let var_sections = organizeVariables(outputData.outputData.model_objects)
+        let var_sections = organizeVariables(outputData.outputData.exports)
         // console.log("var_sections",var_sections)
         return Object.entries(var_sections).map(([key,value])=>{
             //console.log("O key:",key);

electron/ui/src/views/FlowsheetConfig/ConfigOutput/OutputComparison.js

@@ -72,7 +72,7 @@ export default function OutputComparison(props) {
         let var_sections = {}
         let tempVariables = {}
         let tempName = bvars.name
-        for (const [key, v] of Object.entries(bvars.data.outputData.model_objects)) {
+        for (const [key, v] of Object.entries(bvars.data.outputData.exports)) {
             let catg
             let is_input = v.is_input
             let is_output = v.is_output
@@ -143,7 +143,7 @@ export default function OutputComparison(props) {
         let var_sections = {}
         let tempVariables = {}
         let tempName = bvars.name
-        for (const [key, v] of Object.entries(bvars.data.outputData.model_objects)) {
+        for (const [key, v] of Object.entries(bvars.data.outputData.exports)) {
             let catg = v.chart_group
             let chartType = v.chart_type
             if (catg) {

electron/ui/src/views/FlowsheetConfig/FlowsheetConfig.js

@@ -98,7 +98,7 @@ export default function FlowsheetConfig(props) {
       // console.log("flowsheet data use effect")
       // console.log(flowsheetData)
       try {
-        if (flowsheetData.inputData.model_objects && Object.keys(flowsheetData.inputData.model_objects).length > 0) {
+        if (flowsheetData.inputData.exports && Object.keys(flowsheetData.inputData.exports).length > 0) {
           setIsBuilt(true)
         } 
         // else console.log('flowsheet is not built')
@@ -162,7 +162,7 @@ export default function FlowsheetConfig(props) {
       {
         //check if sweep variables all have lower and upper bounds
         let goodToGo = true
-        for (let each of Object.entries(data.model_objects)) {
+        for (let each of Object.entries(data.exports)) {
           if(each[1].is_sweep) {
             if(each[1].ub === null || each[1].lb === null) goodToGo=false
           }