ahuora-builder 0.1.0__py3-none-any.whl

ahuora_builder/custom/tests/test_SimpleEffectivenessHX_DH.py

@@ -0,0 +1,91 @@
+import pyomo.environ as pe# Pyomo environment
+from idaes.core import FlowsheetBlock, StateBlock
+from idaes.models.unit_models import HeatExchanger
+from idaes.models.properties.general_helmholtz import (
+    HelmholtzParameterBlock,
+    PhaseType,
+    StateVars,
+)
+from idaes.models.unit_models.heat_exchanger import HX0DInitializer
+from idaes.models.unit_models.heat_exchanger import delta_temperature_lmtd_callback
+from idaes.models.properties import iapws95
+from ahuora_builder.custom.SimpleEffectivenessHX_DH  import HeatExchangerEffectiveness  
+# from milk_props_full_config  import MilkParameterBlock  
+from idaes.core.util.model_statistics import degrees_of_freedom
+import idaes.logger as idaeslog
+from idaes.core.util import DiagnosticsToolbox
+from multiprocessing import freeze_support
+from property_packages.build_package import build_package
+
+#--------------------------------------------------------------
+#Only works with smooth temperature need the Ahuora smooth helmhotlz, the Ahuora smooth Helmholtz does not work on windows
+#--------------------------------------------------------------
+
+if __name__ == '__main__':
+    freeze_support()
+    # Create an empty flowsheet and steam property parameter block.
+    model = pe.ConcreteModel()
+    model.fs = FlowsheetBlock(dynamic=False)
+    model.fs.properties = build_package("helmholtz",["water"],["Liq","Vap"])  #HelmholtzParameterBlock(pure_component="h2o",state_vars=StateVars.PH,phase_presentation=PhaseType.MIX)
+    dt = DiagnosticsToolbox(model)
+    # Add a Heater model to the flowsheet.
+    model.fs.heat_exchanger = HeatExchangerEffectiveness(
+        hot_side_name="shell",
+        cold_side_name="tube",
+        shell={"property_package": model.fs.properties},
+        tube={"property_package": model.fs.properties},
+
+    )
+
+    model.fs.heat_exchanger.effectiveness.fix(1)
+    model.fs.heat_exchanger.shell_inlet.flow_mol.fix(10)
+    P_hot = 270280
+    T_hot = 200 + 273
+    h = model.fs.properties.htpx(T=T_hot*pe.units.K, p= P_hot*pe.units.Pa)
+    print(h)
+    model.fs.heat_exchanger.shell_inlet.pressure.fix(P_hot)
+    model.fs.heat_exchanger.shell_inlet.enth_mol.fix(h)
+
+    P_cold = 101325
+    T_cold = 50 + 273
+    model.fs.heat_exchanger.tube_inlet.flow_mol.fix(5)
+    model.fs.heat_exchanger.tube_inlet.pressure.fix(P_cold)
+
+    h = model.fs.properties.htpx(T=T_cold*pe.units.K, p= P_cold*pe.units.Pa)
+    print(h)
+    model.fs.heat_exchanger.tube_inlet.enth_mol.fix(h)
+    # Perform degrees of freedom analysis
+    dof = degrees_of_freedom(model)
+    print("Degrees of Freedom:", dof)
+
+
+    # Initialize the model
+    # initializer = HX0DInitializer()
+    # initializer.initialize(model.fs.heat_exchanger)
+    model.fs.heat_exchanger.initialize(outlvl=idaeslog.INFO_HIGH)
+    model.fs.heat_exchanger.report()
+
+    # Solve the models
+    solver = pe.SolverFactory('ipopt')
+    results = solver.solve(model, tee=True)
+
+    # Display the results
+    model.fs.heat_exchanger.report()
+    print("Hot inlet enthalpy theory: ", model.fs.properties.htpx(p= P_hot*pe.units.Pa, T= T_hot*pe.units.K), "J/mol")
+    print("Cold inlet enthalpy theory: ", model.fs.properties.htpx(p= P_cold*pe.units.Pa, T= T_cold*pe.units.K), "J/mol")
+    print("Hot inlet enthalpy: ", pe.value(model.fs.heat_exchanger.hot_side.properties_in[0].enth_mol), "J/mol")
+    print("Cold inlet enthalpy: ", pe.value(model.fs.heat_exchanger.cold_side.properties_in[0].enth_mol), "J/mol")
+    print("Hot outlet enthalpy_max: ", pe.value(model.fs.heat_exchanger.properties_hotside[0].enth_mol), "J/mol")
+    print("Cold outlet enthalpy_max: ", pe.value(model.fs.heat_exchanger.properties_coldside[0].enth_mol), "J/mol")
+    print("dH_hot: ", pe.value(model.fs.heat_exchanger.delta_h_hot_qmax[0]), "J/mol")
+    print("dH_cold: ", pe.value(model.fs.heat_exchanger.delta_h_cold_qmax[0]), "J/mol")
+    print("Duty: ", pe.value(model.fs.heat_exchanger.heat_duty[0])/1e3, "kW")
+    print("Qmax: ", pe.value(model.fs.heat_exchanger.Qmax[0])/1e3, "kW")
+
+
+    eff = pe.value(model.fs.heat_exchanger.effectiveness[0])
+    eff_apparent = pe.value(model.fs.heat_exchanger.heat_duty[0]/model.fs.heat_exchanger.Qmax[0])
+    print("Effectiveness set: ", eff)
+    print("Effectiveness apparent: ", eff_apparent)
+
+

ahuora_builder/custom/tests/test_custom_tank.py

@@ -0,0 +1,70 @@
+from ..custom_tank import DynamicTank
+import pytest
+import pyomo.environ as pyo
+from pyomo.network import Arc
+from idaes.core import FlowsheetBlock, MaterialBalanceType
+from idaes.models.unit_models import Heater, Valve
+from idaes.models.properties import iapws95
+from idaes.core.util.initialization import propagate_state
+from idaes.core.util.model_statistics import degrees_of_freedom
+# need to pip install ahuora_compounds@git+https://github.com/waikato-ahuora-smart-energy-systems/PropertyPackages.git@v0.0.25
+from property_packages.build_package import build_package
+
+def test_dynamic_tank():
+    m = pyo.ConcreteModel()
+    m.fs = FlowsheetBlock(dynamic=True,time_set=[0,1,2,3],time_units=pyo.units.s)
+    m.fs.water = build_package("helmholtz", ["water"],["Liq","Vap"])
+    m.fs.tank = DynamicTank(property_package=m.fs.water,    tank_type="vertical_cylindrical_tank", has_holdup=True,
+    has_heat_transfer=True, dynamic=True)
+
+    m.discretizer = pyo.TransformationFactory("dae.finite_difference")
+    m.discretizer.apply_to(m, nfe=3, wrt=m.fs.time, scheme="BACKWARD")
+
+    # Initialisation - doen't really matter
+    m.fs.tank.control_volume.material_holdup[:,:,:].fix(0.5)
+    m.fs.tank.control_volume.material_holdup[:,:,:].unfix()
+
+    # Setting the required properties
+
+    #Inlet state - all timesteps
+    m.fs.tank.inlet.flow_mol.fix(100)
+    m.fs.tank.inlet.enth_mol.fix(m.fs.water.htpx(300 * pyo.units.K,101325* pyo.units.Pa)) # around 5 deg c
+    m.fs.tank.inlet.pressure.fix(101325)
+
+    #Tank properties
+    m.fs.tank.tank_diameter.fix(0.5) # m
+    m.fs.tank.heat_duty.fix(0)  # W
+    m.fs.tank.outlet.flow_mol.fix(10)
+    
+    #Initial conditions
+    m.fs.tank.initial_temperature.fix(300)
+    m.fs.tank.initial_pressure.fix(101325)
+    m.fs.tank.initial_holdup.fix(1000)
+
+    assert degrees_of_freedom(m.fs) == 0
+
+    m.fs.tank.initialize()
+
+
+    opt = pyo.SolverFactory("ipopt")
+    results = opt.solve(m, tee=False)
+    #m.fs.tank.display()
+    
+    b = m.fs.tank
+
+    assert results.solver.termination_condition == pyo.TerminationCondition.optimal
+    
+    # print("Enthalpy Liquid:   Enthalpy Vap:   Material Holdup Liquid: Material Holdup Vap")
+    # for t in m.fs.time:
+    #     print(m.fs.tank.enthalpy[t,"Liq"].value, m.fs.tank.enthalpy[t,"Vap"].value, pyo.value(m.fs.tank.material_phase_holdup[t,"Liq"]), pyo.value(m.fs.tank.material_phase_holdup[t,"Vap"]))
+
+    # for t in m.fs.time:
+    #     print(m.fs.tank.outlet.enth_mol[t].value, m.fs.tank.outlet.flow_mol[t].value, pyo.value(m.fs.tank.control_volume.properties_out[t].temperature), pyo.value(m.fs.tank.control_volume.properties_in[t].temperature))
+        
+
+    assert pyo.value(b.outlet.enth_mol[0]) == pytest.approx(pyo.value(b.inlet.enth_mol[0]), rel=1e-1)
+
+
+
+if __name__ == "__main__":
+    test_dynamic_tank()

ahuora_builder/custom/tests/test_direct_steam_injection.py

@@ -0,0 +1,41 @@
+from ..direct_steam_injection import Dsi
+import pytest
+import pyomo.environ as pyo
+from pyomo.network import Arc
+from idaes.core import FlowsheetBlock, MaterialBalanceType
+from idaes.models.unit_models import Heater, Valve
+from idaes.models.properties import iapws95
+from idaes.core.util.initialization import propagate_state
+from idaes.core.util.model_statistics import degrees_of_freedom
+# need to pip install ahuora_compounds@git+https://github.com/waikato-ahuora-smart-energy-systems/PropertyPackages.git@v0.0.25
+from property_packages.build_package import build_package
+
+def test_dsi():
+    m = pyo.ConcreteModel()
+    m.fs = FlowsheetBlock(dynamic=False)
+    m.fs.steam_properties = build_package("helmholtz", ["water"],["Liq","Vap"])
+    m.fs.milk_properties = build_package("milk", ["water","milk_solid"],["Liq","Vap"])
+    m.fs.dsi = Dsi(property_package=m.fs.milk_properties,steam_property_package=m.fs.steam_properties)
+    
+    m.fs.dsi.inlet.flow_mol.fix(1)
+    m.fs.dsi.properties_milk_in[0].constrain_component(m.fs.dsi.properties_milk_in[0].temperature, 300 * pyo.units.K)
+    m.fs.dsi.inlet.pressure.fix(101325)
+    m.fs.dsi.inlet.mole_frac_comp[0,"water"].fix(0.9)
+    m.fs.dsi.inlet.mole_frac_comp[0,"milk_solid"].fix(0.1)
+
+    m.fs.dsi.steam_inlet.flow_mol.fix(1)
+    m.fs.dsi.properties_steam_in[0].constrain_component(m.fs.dsi.properties_steam_in[0].temperature, 400 * pyo.units.K)
+    m.fs.dsi.steam_inlet.pressure.fix(101325)
+
+    m.fs.dsi.initialize()
+    assert degrees_of_freedom(m.fs.dsi.properties_milk_in) == 0
+    assert degrees_of_freedom(m.fs.dsi.properties_steam_in) == 0
+    assert degrees_of_freedom(m.fs) == 0
+
+    opt = pyo.SolverFactory("ipopt")
+    results = opt.solve(m, tee=True)
+    
+    assert results.solver.termination_condition == pyo.TerminationCondition.optimal
+    assert degrees_of_freedom(m.fs) == 0
+
+

ahuora_builder/custom/tests/test_simple_separator.py

@@ -0,0 +1,46 @@
+import pytest
+from pyomo.environ import ConcreteModel, SolverFactory, value
+from idaes.core import FlowsheetBlock
+from idaes.models.properties.iapws95 import Iapws95ParameterBlock
+from idaes.core.util.model_statistics import degrees_of_freedom
+from ahuora_builder.custom.simple_separator import SimpleSeparator
+
+
+def test_simple_separator_iapws95():
+    m = ConcreteModel()
+    m.fs = FlowsheetBlock(dynamic=False)
+
+    # Property package: IAPWS95 (pure water/steam)
+    m.fs.properties = Iapws95ParameterBlock()
+
+    # Add SimpleSeparator with 2 outlets
+    m.fs.sep = SimpleSeparator(
+        property_package=m.fs.properties,
+        num_outlets=2,
+    )
+
+    # Fix inlet state
+    m.fs.sep.inlet.flow_mol[0].fix(100.0)      # mol/s
+    m.fs.sep.inlet.enth_mol[0].fix(50000.0)    # J/mol (example enthalpy)
+    m.fs.sep.inlet.pressure[0].fix(101325.0)   # Pa
+
+    # Fix split fractions
+    m.fs.sep.outlet_1.flow_mol[0].fix(70.0)  # mol/s
+
+    # Model should be fully specified
+    assert degrees_of_freedom(m) == 0
+
+    # Initialize and solve
+    m.fs.sep.initialize()
+    solver = SolverFactory("ipopt")
+    results = solver.solve(m, tee=False)
+    assert results.solver.termination_condition == "optimal"
+
+    # Check material balance
+    inlet_flow = value(m.fs.sep.inlet.flow_mol[0])
+    out1_flow = value(m.fs.sep.outlet_1.flow_mol[0])
+    out2_flow = value(m.fs.sep.outlet_2.flow_mol[0])
+
+    assert abs(inlet_flow - (out1_flow + out2_flow)) <= 1e-6
+    assert abs(out1_flow - 0.7 * inlet_flow) <= 1e-6
+    assert abs(out2_flow - 0.3 * inlet_flow) <= 1e-6

ahuora_builder/custom/tests/test_waterpipe.py

@@ -0,0 +1,46 @@
+import pytest
+import pyomo.environ as pyo
+from idaes.core import FlowsheetBlock
+from idaes.models.properties import iapws95
+from idaes.models_extra.power_generation.unit_models.waterpipe import WaterPipe
+from idaes.core.util.model_statistics import degrees_of_freedom
+from idaes.core.util.testing import initialization_tester
+from idaes.core.solvers import get_solver
+
+solver = get_solver()
+
+def test_waterpipe_simple():
+    '''
+    Simple test for the WaterPipe unit model
+    '''
+    m = pyo.ConcreteModel()
+    m.fs = FlowsheetBlock(dynamic=False)
+    m.fs.properties = iapws95.Iapws95ParameterBlock()
+    m.fs.pipe = WaterPipe(
+        dynamic=False,
+        property_package=m.fs.properties,
+        has_holdup=True,
+        has_heat_transfer=False,
+        has_pressure_change=True,
+        water_phase="Liq",
+        contraction_expansion_at_end="None",
+    )
+    m.fs.pipe.diameter.fix(0.04)
+    m.fs.pipe.length.fix(40)
+    m.fs.pipe.number_of_pipes.fix(100)
+    m.fs.pipe.elevation_change.fix(25)
+    m.fs.pipe.fcorrection_dp.fix(1.0)
+
+    state_args = {"flow_mol": 10000, "pressure": 1.3e7, "enth_mol": 18000}
+    initialization_tester(m, dof=3, state_args=state_args, unit=m.fs.pipe)
+    m.fs.pipe.inlet.enth_mol.fix()
+    m.fs.pipe.inlet.flow_mol.fix()
+    m.fs.pipe.inlet.pressure.fix()
+    assert degrees_of_freedom(m) == 0
+
+    results = solver.solve(m, tee=True)
+    assert pyo.check_optimal_termination(results)
+    # Output for debugging
+    print("Outlet pressure:", pyo.value(m.fs.pipe.outlet.pressure[0]))
+    print("Pressure drop:", pyo.value(m.fs.pipe.deltaP[0]))
+    print("Outlet enthalpy:", pyo.value(m.fs.pipe.outlet.enth_mol[0]))