重构质量模型并补充回热器分段建模

brayton_cycle/__init__.py

@@ -11,27 +11,15 @@ from .components import (
 )
 from .cycles import BraytonCycle
 from .mass_models import (
-    PCHEGeometry,
+    apply_component_mass,
-    PCHEMaterial,
+    calculate_component_mass,
-    PCHEDesignOptions,
+    condenser_radiator_mass,
-    PCHE_STATE_UNIT_CONVENTION,
+    has_default_mass_model,
-    calculate_condenser_mass,
+    heater_reactor_mass,
-    calculate_heater_mass,
+    initialize_recuperator_segments,
-    calculate_turbine_mass,
+    recuperator_pche_mass,
-    calculate_water_outlet_temperature,
+    RecuperatorPCHEMassModel,
-    flow_velocity,
+    turbine_tac_mass,
-    friction_factor,
-    gnielinski_f_star,
-    heat_transfer_coefficient,
-    nusselt_number,
-    overall_heat_transfer_coefficient,
-    pche_channel_flow_area,
-    pche_channel_wetted_perimeter,
-    pche_equivalent_diameter,
-    prandtl_number,
-    pressure_drop_pa,
-    reynolds_number,
-    validate_pche_state,
 )
 from .optimization import (
     optimize_rc_fixed_param,
@@ -56,36 +44,24 @@ __all__ = [
     "Concentrator",
     "Condenser",
     "Heater",
-    "PCHEGeometry",
-    "PCHEMaterial",
-    "PCHEDesignOptions",
-    "PCHE_STATE_UNIT_CONVENTION",
     "Recuperator",
+    "RecuperatorPCHEMassModel",
     "Turbine",
-    "calculate_condenser_mass",
+    "apply_component_mass",
-    "calculate_heater_mass",
+    "calculate_component_mass",
-    "calculate_turbine_mass",
+    "condenser_radiator_mass",
-    "calculate_water_outlet_temperature",
-    "flow_velocity",
-    "friction_factor",
-    "gnielinski_f_star",
-    "heat_transfer_coefficient",
     "evaluate_rc_efficiency",
+    "has_default_mass_model",
+    "heater_reactor_mass",
+    "initialize_recuperator_segments",
     "local_rc_component_performance_sensitivity",
     "local_rc_design_sensitivity",
-    "nusselt_number",
     "optimize_rc_fixed_param",
     "optimize_rc_param",
-    "overall_heat_transfer_coefficient",
-    "pche_channel_flow_area",
-    "pche_channel_wetted_perimeter",
-    "pche_equivalent_diameter",
     "plot_optimization_landscape",
     "plot_sweep_optimization_results",
-    "prandtl_number",
+    "recuperator_pche_mass",
-    "pressure_drop_pa",
-    "reynolds_number",
     "scan_rc_efficiency",
     "sweep_and_optimize_rc",
-    "validate_pche_state",
+    "turbine_tac_mass",
 ]

brayton_cycle/components.py

@@ -1,15 +1,9 @@
 # -*- coding: utf-8 -*-
 """Component models used by Brayton cycle simulations."""
 
-from .mass_models import (
-    calculate_condenser_mass,
-    calculate_heater_mass,
-    calculate_turbine_mass,
-)
-
 
 class ComponentMassMixin:
-    """Shared mass-calculation interface for cycle components."""
+    """Shared mass-result storage interface for cycle components."""
 
     component_type = "component"
 
@@ -17,43 +11,16 @@ class ComponentMassMixin:
         self.mass = None
         self.mass_variables = None
 
-    def calculate_mass(self, mass_model=None, **kwargs):
+    def set_mass_result(self, result):
-        """Calculate and store component mass.
+        """Store a mass-model result on this component.
 
-        The future mass model can be provided as either a callable accepting
+        Mass formulas live in ``brayton_cycle.mass_models``. Components only
-        ``(component, **kwargs)`` or an object exposing ``calculate_mass`` or
+        keep the result after their thermodynamic calculator has populated
-        ``calculate_<component_type>_mass``.
+        ``variables``.
         """
         if self.variables is None:
-            raise ValueError("Run component calculator before mass calculation")
+            raise ValueError("Run component calculator before storing mass")
 
-        if mass_model is None:
-            result = self._calculate_mass(**kwargs)
-        else:
-            result = self._run_external_mass_model(mass_model, **kwargs)
-
-        return self._store_mass_result(result)
-
-    def mass_calculator(self, mass_model=None, **kwargs):
-        return self.calculate_mass(mass_model=mass_model, **kwargs)
-
-    def _calculate_mass(self, **kwargs):
-        raise NotImplementedError(
-            f"{self.__class__.__name__} mass model is not implemented yet. "
-            "Pass a mass_model or override _calculate_mass()."
-        )
-
-    def _run_external_mass_model(self, mass_model, **kwargs):
-        method_name = f"calculate_{self.component_type}_mass"
-        if hasattr(mass_model, method_name):
-            return getattr(mass_model, method_name)(self, **kwargs)
-        if hasattr(mass_model, "calculate_mass"):
-            return mass_model.calculate_mass(self, **kwargs)
-        if callable(mass_model):
-            return mass_model(self, **kwargs)
-        raise TypeError("mass_model must be callable or expose a supported method")
-
-    def _store_mass_result(self, result):
         if isinstance(result, dict):
             if "mass" in result:
                 mass = result["mass"]
@@ -72,8 +39,17 @@ class ComponentMassMixin:
         self.variables["mass_variables"] = self.mass_variables
         return self.mass
 
-class Compressor():
+    def clear_mass_result(self):
+        self.mass = None
+        self.mass_variables = None
+        if self.variables is not None:
+            self.variables.pop("mass", None)
+            self.variables.pop("mass_variables", None)
+
+class Compressor(ComponentMassMixin):
     """压缩机类"""
+    component_type = "compressor"
+
     def __init__(self, name, eff):
         """
         初始化参数
@@ -89,6 +65,7 @@ class Compressor():
         self.name = name
         self.eff = eff
         self.variables = None
+        self._init_mass_interface()
         
     def calculator(self, p_in, T_in, p_out, property_calculator):
         # 先计算熵值
@@ -167,9 +144,6 @@ class Turbine(ComponentMassMixin):
             'pi': p_in / p_out
             }
 
-    def _calculate_mass(self, Pe=None, A=0.5, **kwargs):
-        return calculate_turbine_mass(self, Pe=Pe, A=A, **kwargs)
-
 class Recuperator(ComponentMassMixin):
     """换热器类"""
     component_type = "recuperator"
@@ -360,23 +334,6 @@ class Heater(ComponentMassMixin):
             'Q_in': Q_input,
             }
 
-    def _calculate_mass(
-        self,
-        P_heat_mwt=None,
-        mass_flow_rate=None,
-        shielding_mass_ton=2.8,
-        include_shielding=True,
-        **kwargs,
-    ):
-        return calculate_heater_mass(
-            self,
-            P_heat_mwt=P_heat_mwt,
-            mass_flow_rate=mass_flow_rate,
-            shielding_mass_ton=shielding_mass_ton,
-            include_shielding=include_shielding,
-            **kwargs,
-        )
-
 class Condenser(ComponentMassMixin):
     """冷凝器类"""
     component_type = "condenser"
@@ -405,35 +362,6 @@ class Condenser(ComponentMassMixin):
             'Q_out': Q_output,
             }
 
-    def _calculate_mass(
-        self,
-        Qc_kw=None,
-        co2_mass_flow_rate=None,
-        coolant_outlet_T=None,
-        water_inlet_T=None,
-        water_mass_flow_rate=None,
-        water_pressure_kpa=101.325,
-        refprop_path="C:/Program Files (x86)/REFPROP 10.0+/REFPROP",
-        emissivity=0.92,
-        surface_temperature=210.15,
-        area_density=6.75,
-        **kwargs,
-    ):
-        return calculate_condenser_mass(
-            self,
-            Qc_kw=Qc_kw,
-            co2_mass_flow_rate=co2_mass_flow_rate,
-            coolant_outlet_T=coolant_outlet_T,
-            water_inlet_T=water_inlet_T,
-            water_mass_flow_rate=water_mass_flow_rate,
-            water_pressure_kpa=water_pressure_kpa,
-            refprop_path=refprop_path,
-            emissivity=emissivity,
-            surface_temperature=surface_temperature,
-            area_density=area_density,
-            **kwargs,
-        )
-
 class Concentrator(ComponentMassMixin):
     """汇流组件"""
     component_type = "concentrator"

brayton_cycle/cycles.py

@@ -9,6 +9,7 @@ from .components import (
     Recuperator,
     Turbine,
 )
+from .mass_models import apply_component_mass, has_default_mass_model
 from .properties import CO2PropertyCalculator
 
 
@@ -57,13 +58,31 @@ class BraytonCycle:
             else:
                 yield value
 
-    def calculate_component_masses(self, mass_model=None, **kwargs):
+    def calculate_component_masses(self, mass_model=None, strict=False, **kwargs):
         """Calculate mass for each initialized component."""
         component_masses = {}
         for component in self.iter_components():
-            if not hasattr(component, "calculate_mass"):
+            if not hasattr(component, "set_mass_result"):
                 continue
-            mass = component.calculate_mass(mass_model=mass_model, **kwargs)
+            if mass_model is None and not has_default_mass_model(component):
+                if strict:
+                    raise NotImplementedError(
+                        f"No default mass model for component type "
+                        f"{component.component_type!r}."
+                    )
+                continue
+
+            try:
+                mass = apply_component_mass(
+                    component,
+                    mass_model=mass_model,
+                    **kwargs,
+                )
+            except NotImplementedError:
+                if strict:
+                    raise
+                continue
+
             key = component.variables.get("name", component.name)
             component_masses[key] = {
                 "component_type": component.component_type,
@@ -74,18 +93,23 @@ class BraytonCycle:
         self.component_masses = component_masses
         return self.component_masses
 
-    def cycle_mass_calculator(self, mass_model=None, **kwargs):
+    def cycle_mass_calculator(self, mass_model=None, strict=False, **kwargs):
         """Calculate and return total cycle component mass."""
         component_masses = self.calculate_component_masses(
             mass_model=mass_model,
+            strict=strict,
             **kwargs,
         )
         self.total_mass = sum(item["mass"] for item in component_masses.values())
         return self.total_mass
 
-    def calculate_total_mass(self, mass_model=None, **kwargs):
+    def calculate_total_mass(self, mass_model=None, strict=False, **kwargs):
         """Compatibility alias for cycle_mass_calculator."""
-        return self.cycle_mass_calculator(mass_model=mass_model, **kwargs)
+        return self.cycle_mass_calculator(
+            mass_model=mass_model,
+            strict=strict,
+            **kwargs,
+        )
 
     def SC(self, T_low, T_high, p_low, p_high, param=None):
         """Simple Brayton cycle."""

brayton_cycle/properties.py

@@ -15,7 +15,7 @@ class CO2PropertyCalculator():
         self.rp.SETUPdll(2, 'SI', 'SI', 'DEF')
         self.z = [1.0]
         self.mw = self.rp.WMOLdll(self.z)
-    def calculate_properties(self, T=None, P=None, h=None, s=None, include_transport=False):
+    def calculate_properties(self, T=None, P=None, h=None, s=None):
         """计算二氧化碳物性"""
         if T is not None and P is not None:
             # 已知Tp
@@ -60,32 +60,15 @@ class CO2PropertyCalculator():
         
         # 补充提取的物性，这里由于后续还要使用，不进行参数变换
         properties['D'] = result.D
+        properties['density_kg_m3'] = result.D * self.mw
         properties['cp'] = result.Cp
-        properties['cv'] = result.Cv,
+        properties['cp_j_kg_k'] = result.Cp / self.mw * 1000
-        properties['rho'] = result.D * self.mw
+        properties['cv'] = result.Cv
-        properties['cp_mass'] = result.Cp / self.mw * 1000.0
+        properties['cv_j_kg_k'] = result.Cv / self.mw * 1000
-        properties['cv_mass'] = result.Cv / self.mw * 1000.0
-        if include_transport:
-            self._add_transport_properties(properties, result)
-        return properties
 
-    def _add_transport_properties(self, properties, result):
+        transport = self.rp.TRNPRPdll(result.T, result.D, self.z)
-        """Add CO2 transport properties needed by PCHE correlations."""
+        if transport.ierr > 0:
-        transport = self.rp.TRNPRPdll(properties['T'], result.D, self.z)
-        if getattr(transport, 'ierr', 0) > 0:
             raise ValueError(f"REFPROP transport calculation error:{transport.ierr}")
-
+        properties['viscosity_pa_s'] = transport.eta * 1e-6
-        viscosity_micro_pa_s = getattr(transport, 'eta', None)
+        properties['thermal_conductivity_w_m_k'] = transport.tcx
-        thermal_conductivity = getattr(transport, 'tcx', None)
+        return properties
-        if viscosity_micro_pa_s is None:
-            viscosity_micro_pa_s = getattr(transport, 'visc', None)
-        if thermal_conductivity is None:
-            thermal_conductivity = getattr(transport, 'tcond', None)
-        if viscosity_micro_pa_s is None or thermal_conductivity is None:
-            raise ValueError("REFPROP transport result missing viscosity or conductivity")
-
-        viscosity_pa_s = viscosity_micro_pa_s * 1.0e-6
-        properties['mu'] = viscosity_pa_s
-        properties['viscosity'] = viscosity_pa_s
-        properties['lambda'] = thermal_conductivity
-        properties['thermal_conductivity'] = thermal_conductivity