ahuora-builder 0.1.0__py3-none-any.whl

ahuora_builder/custom/thermal_utility_systems/tests/test_ntu_hx.py

@@ -0,0 +1,129 @@
+import pytest
+ 
+from pyomo.environ import (
+    check_optimal_termination,
+    ConcreteModel,
+    Constraint,
+    Expression,
+    Param,
+    units as pyunits,
+    value,
+    Var,
+)
+from pyomo.util.check_units import assert_units_consistent, assert_units_equivalent
+ 
+from idaes.core import FlowsheetBlock
+from idaes.models.unit_models.heat_exchanger_ntu import (
+    HeatExchangerNTU as HXNTU,
+    HXNTUInitializer,
+)
+ 
+from idaes.models.properties.modular_properties.base.generic_property import (
+    GenericParameterBlock,
+)
+from idaes.models_extra.column_models.properties.MEA_solvent import (
+    configuration as aqueous_mea,
+)
+from idaes.core.util.model_statistics import degrees_of_freedom
+from idaes.core.solvers import get_solver
+from idaes.core.util.testing import initialization_tester, PhysicalParameterTestBlock
+from idaes.core.util.exceptions import ConfigurationError, InitializationError
+from idaes.core.initialization import (
+    BlockTriangularizationInitializer,
+    InitializationStatus,
+)
+from idaes.core.util import DiagnosticsToolbox    
+from idaes.models.properties import iapws95
+
+def test_ntu_hx():
+    m = ConcreteModel()
+    m.fs = FlowsheetBlock(dynamic=False)
+    m.fs.properties = iapws95.Iapws95ParameterBlock(
+    phase_presentation=iapws95.PhaseType.MIX,
+    state_vars=iapws95.StateVars.PH
+    )
+    import math
+    
+    m.fs.unit = HXNTU(
+        hot_side={
+            "property_package": m.fs.properties,
+            "has_pressure_change": False,
+        },
+        cold_side={
+            "property_package": m.fs.properties,
+            "has_pressure_change": False,
+        },
+    )
+    
+    # Hot fluid
+    m.fs.unit.hot_side_inlet.flow_mol[0].fix(60.54879)
+    m.fs.unit.hot_side_inlet.enth_mol[0].fix(m.fs.properties.htpx(p=202650*pyunits.Pa, T=392.23*pyunits.K))
+    #m.fs.unit.hot_side_inlet.temperature[0].fix(392.23)
+    m.fs.unit.hot_side_inlet.pressure[0].fix(202650)
+    
+    
+    # Cold fluid
+    m.fs.unit.cold_side_inlet.flow_mol[0].fix(63.01910)
+    m.fs.unit.cold_side_inlet.enth_mol[0].fix(m.fs.properties.htpx(p=202650*pyunits.Pa, T=326.36*pyunits.K))
+    #m.fs.unit.cold_side_inlet.temperature[0].fix(326.36)
+    m.fs.unit.cold_side_inlet.pressure[0].fix(202650)
+    
+    
+    # Unit design variables
+    m.fs.unit.area.fix(100)
+    m.fs.unit.heat_transfer_coefficient.fix(200)
+    e = 0.7
+    m.fs.unit.effectiveness.fix(e)
+    
+    # m.fs.unit.hot_side.deltaP.fix(-2000)
+    # m.fs.unit.cold_side.deltaP.fix(-2000)
+    
+    m.fs.unit.initialize()
+    
+    solver = get_solver()
+    results = solver.solve(m, tee=True)
+    
+    m.fs.unit.report()
+    print(value(m.fs.unit.NTU[0]))
+    print(value(m.fs.unit.heat_duty[0]))
+    print(value(m.fs.unit.Cmin[0]))
+    print(value(m.fs.unit.Cmax[0]))
+    
+    if value(m.fs.unit.hot_side.properties_in[0].flow_mol * m.fs.unit.hot_side.properties_in[0].cp_mol) < value(m.fs.unit.cold_side.properties_in[0].flow_mol * m.fs.unit.cold_side.properties_in[0].cp_mol):
+        Cmin = value(
+            m.fs.unit.hot_side.properties_in[0].flow_mol
+            * m.fs.unit.hot_side.properties_in[0].cp_mol
+        )
+        Cmax = value(
+            m.fs.unit.cold_side.properties_in[0].flow_mol
+            * m.fs.unit.cold_side.properties_in[0].cp_mol
+        )
+    else:
+        Cmax = value(
+            m.fs.unit.hot_side.properties_in[0].flow_mol
+            * m.fs.unit.hot_side.properties_in[0].cp_mol
+        )
+        Cmin = value(
+                m.fs.unit.hot_side.properties_in[0].flow_mol
+                * m.fs.unit.hot_side.properties_in[0].cp_mol
+            )
+    
+    NTU = value(m.fs.unit.heat_transfer_coefficient[0] * m.fs.unit.area / Cmin)
+    Q_duty = value(Cmin * e * (m.fs.unit.hot_side.properties_in[0].temperature - m.fs.unit.cold_side.properties_in[0].temperature))
+    # Cmin = 5
+    # Cmax = 5
+    #NTU = 18
+    #Q_duty = 20
+    assert math.isclose(value(m.fs.unit.Cmin[0]), Cmin, rel_tol=1e-5), (
+        f"Cmin mismatch: model={value(m.fs.unit.Cmin[0])}, calculated={Cmin}"
+    )
+    
+    assert math.isclose(value(m.fs.unit.Cmax[0]), Cmax, rel_tol=1e-5), (
+        f"Cmax mismatch: model={value(m.fs.unit.Cmax[0])}, calculated={Cmax}"
+    )
+    assert math.isclose(value(m.fs.unit.NTU[0]), NTU, rel_tol=1e-5), (
+        f"NTU mismatch: model={value(m.fs.unit.NTU[0])}, calculated={NTU}"
+    )
+    assert math.isclose(value(m.fs.unit.heat_duty[0]), Q_duty, rel_tol=1e-5), (
+        f"Heat duty mismatch: model={value(m.fs.unit.heat_duty[0])}, calculated={Q_duty}"
+    )

ahuora_builder/custom/thermal_utility_systems/tests/test_simple_heat_pump.py

@@ -0,0 +1,120 @@
+import pytest
+
+from ahuora_builder.custom.thermal_utility_systems.simple_heat_pump import (
+    SimpleHeatPump,
+)
+
+import pyomo.environ as pyo
+from idaes.core import FlowsheetBlock
+from idaes.core.util.model_statistics import degrees_of_freedom
+#from property_packages.build_package import build_package # build package still broken for windows users
+from idaes.models.properties.general_helmholtz import (
+    HelmholtzParameterBlock,
+    PhaseType,
+    StateVars,
+    AmountBasis,
+    )
+
+from pyomo.network import Arc, SequentialDecomposition
+import idaes.logger as idaeslog
+import math
+
+def _make_case():
+    m = pyo.ConcreteModel()
+    m.fs = FlowsheetBlock(dynamic = False)
+    m.fs.water = HelmholtzParameterBlock(
+                    pure_component="h2o",
+                    phase_presentation=PhaseType.LG,
+                    state_vars=StateVars.PH,
+                    amount_basis=AmountBasis.MOLE,
+                    )
+    #build_package("helmholtz", ["water"], ["Liq", "Vap"])
+
+    m.fs.hp = SimpleHeatPump(source={
+        "property_package": m.fs.water,
+        "has_pressure_change": False,
+    }, sink={
+        "property_package": m.fs.water,
+        "has_pressure_change": False,
+    })
+    
+    # Set source (hot side) conditions
+    T_source_in = (80 + 273.15) * pyo.units.K  # K
+    P_source_in = 4e5 * pyo.units.Pa  # Pa
+    F_source_in = 29 * 15.4 * pyo.units.mol / pyo.units.s  # mol/s
+
+    m.fs.hp.source_inlet.flow_mol.fix(F_source_in)  # mol/s
+    m.fs.hp.source_inlet.pressure.fix(P_source_in)  # 4 Bar
+    m.fs.hp.source_inlet.enth_mol.fix(
+        m.fs.water.htpx(T_source_in , m.fs.hp.source_inlet.pressure[0])
+    )  # J/mol
+    m.fs.hp.approach_temperature.fix(10)  # K
+
+    # Set sink (cold side) conditions
+    T_sink_in = (90 + 273.15) * pyo.units.K  # K
+    P_sink_in = 8e5 * pyo.units.Pa  # Pa
+    F_sink_in = 1.1 * 15.4 * pyo.units.mol / pyo.units.s  # mol/s
+
+    m.fs.hp.sink_inlet.flow_mol.fix(F_sink_in)  # mol/s
+    m.fs.hp.sink_inlet.pressure.fix(P_sink_in)  # 10 Bar
+    m.fs.hp.sink_inlet.enth_mol.fix(
+        m.fs.water.htpx(T_sink_in, m.fs.hp.sink_inlet.pressure[0])
+    )  # J/mol
+    
+    return m
+ 
+def _assert_solution(m):
+    eps_rel = 1e-4 
+    eps_abs = 0.1
+    m.fs.hp.initialize()
+
+    assert degrees_of_freedom(m) == 0
+
+    solver = pyo.SolverFactory("ipopt")
+    solver.solve(m, tee=True)
+    
+    # Check heat balances Qsink = Qsource + W
+    Q_sink = pyo.value(m.fs.hp.sink_inlet.flow_mol[0] * (m.fs.hp.sink_outlet.enth_mol[0] - m.fs.hp.sink_inlet.enth_mol[0] ))
+    Q_source = pyo.value(m.fs.hp.source_inlet.flow_mol[0] * (m.fs.hp.source_inlet.enth_mol[0] - m.fs.hp.source_outlet.enth_mol[0] ))
+    
+    assert Q_sink - pyo.value(m.fs.hp.work_mechanical[0]) - Q_source == pytest.approx(0, rel=eps_rel, abs=eps_abs)     
+    assert abs(pyo.value(m.fs.hp.source.heat[0])) == pytest.approx(Q_source, rel=eps_rel, abs=eps_abs)
+    assert abs(pyo.value(m.fs.hp.sink.heat[0])) == pytest.approx(Q_sink, rel=eps_rel, abs=eps_abs)
+    
+    # Check that CoP is calculated correctly
+    assert pyo.value(m.fs.hp.coefficient_of_performance) == pytest.approx(Q_sink / pyo.value(m.fs.hp.work_mechanical[0]), rel=eps_rel, abs=eps_abs)
+    
+    # Check that duties and CoP are as expected from datasheet
+    assert pyo.value(m.fs.hp.coefficient_of_performance) == pytest.approx(1.9, rel=0.05, abs=0.2)
+    assert pyo.value(m.fs.hp.sink.heat[0]) == pytest.approx(720e3, rel=0.05, abs=50e3)
+    
+    m.fs.hp.report()
+    
+
+def test_heat_pump_with_work_and_efficiency():
+    m = _make_case()
+    # Fix efficiency to the Ovolondo heat pump
+    m.fs._ = pyo.Constraint(expr=m.fs.hp.efficiency == 0.3305 + 0.2723 * pyo.tanh((m.fs.hp.delta_temperature_lift[0] - 57.64) / 74.19))
+    m.fs.hp.approach_temperature.fix(10)  # K
+    # Fix mechanical work to the example
+    m.fs.hp.work_mechanical.fix(380e3)  # W
+    
+    assert degrees_of_freedom(m) == 0
+    
+    _assert_solution(m)
+    
+def test_heat_pump_with_sink_outlet_and_efficiency():
+    m = _make_case()
+    
+    # Fix efficiency to the Ovolondo heat pump
+    m.fs._ = pyo.Constraint(expr=m.fs.hp.efficiency == 0.3305 + 0.2723 * pyo.tanh((m.fs.hp.delta_temperature_lift[0] - 57.64) / 74.19))
+    m.fs.hp.approach_temperature.fix(10)  # K
+    # Fix sink outlet temperature to the Ovolondo heat pump
+    T_sink_out = (171 + 273.15) * pyo.units.K  # K
+    m.fs.hp.sink_outlet.enth_mol.fix(
+        m.fs.water.htpx(T_sink_out , m.fs.hp.sink_inlet.pressure[0])
+    )  # J/mol
+    
+    assert degrees_of_freedom(m) == 0
+    
+    _assert_solution(m)