611 lines
19 KiB
Python
611 lines
19 KiB
Python
from __future__ import annotations
|
|
|
|
from collections.abc import Mapping
|
|
from math import isclose, sqrt
|
|
|
|
from app.simulation.core.base import AlgebraicComponent
|
|
from app.simulation.core.catalog import ComponentDisplaySpec, PortDisplaySpec
|
|
from app.simulation.core.equations import EquationResidual
|
|
from app.simulation.core.metadata import (
|
|
ParameterDefinition,
|
|
ResultVariableDefinition,
|
|
)
|
|
from app.simulation.core.medium import IdealGasMedium
|
|
from app.simulation.core.ports import PortDefinition
|
|
|
|
|
|
class AmesimPnor001(AlgebraicComponent):
|
|
"""AMESim PNOR001 constant-flow-coefficient pneumatic orifice.
|
|
|
|
This public component preserves the PNOR001 catalog/XML contract and uses a
|
|
finite bidirectional compressible-orifice approximation. The Siemens
|
|
`pn2rcqfix_` details remain a later calibration target.
|
|
"""
|
|
|
|
MODEL_TYPE = "amesim_pnor001"
|
|
MODEL_VERSION = "0.1.0"
|
|
PORTS = (
|
|
PortDefinition.pneumatic("port_1", nominal_role="bidirectional"),
|
|
PortDefinition.pneumatic("port_2", nominal_role="bidirectional"),
|
|
)
|
|
PARAMETERS = (
|
|
ParameterDefinition(
|
|
"cq",
|
|
0.72,
|
|
label="流量系数 Cq",
|
|
quantity="dimensionless",
|
|
unit="",
|
|
minimum=1.0e-10,
|
|
maximum=1.0,
|
|
),
|
|
ParameterDefinition(
|
|
"area",
|
|
5.0e-6,
|
|
label="孔口面积",
|
|
quantity="area",
|
|
unit="m2",
|
|
minimum=0.0,
|
|
maximum=1.0,
|
|
),
|
|
ParameterDefinition(
|
|
"Cv",
|
|
0.5,
|
|
label="流量系数 Cv",
|
|
quantity="dimensionless",
|
|
unit="",
|
|
minimum=0.0,
|
|
),
|
|
ParameterDefinition(
|
|
"Kv",
|
|
0.4,
|
|
label="流量系数 Kv",
|
|
quantity="dimensionless",
|
|
unit="",
|
|
minimum=0.0,
|
|
),
|
|
ParameterDefinition(
|
|
"gi",
|
|
1.0,
|
|
label="气体类型索引",
|
|
quantity="dimensionless",
|
|
unit="",
|
|
minimum=1.0,
|
|
maximum=99.0,
|
|
),
|
|
ParameterDefinition(
|
|
"flowset",
|
|
1.0,
|
|
label="流量系数设置",
|
|
quantity="dimensionless",
|
|
unit="",
|
|
minimum=1.0,
|
|
maximum=3.0,
|
|
),
|
|
)
|
|
RESULT_VARIABLES = (
|
|
ResultVariableDefinition(
|
|
"cm",
|
|
label="质量流量参数",
|
|
quantity="dimensionless",
|
|
unit="",
|
|
category="derived",
|
|
order=10,
|
|
),
|
|
ResultVariableDefinition(
|
|
"gasvel",
|
|
label="缩流截面气体速度",
|
|
quantity="velocity",
|
|
unit="m/s",
|
|
category="derived",
|
|
order=20,
|
|
),
|
|
)
|
|
DISPLAY = ComponentDisplaySpec(
|
|
label="PNOR001 常系数气动孔口",
|
|
library_id="amesim",
|
|
category_id="flow",
|
|
symbol="orifice",
|
|
ports=(
|
|
PortDisplaySpec("port_1", "left", order=10),
|
|
PortDisplaySpec("port_2", "right", order=20),
|
|
),
|
|
order=10,
|
|
)
|
|
|
|
def __init__(
|
|
self,
|
|
name: str,
|
|
medium: IdealGasMedium,
|
|
*,
|
|
cq: float = 0.72,
|
|
area: float = 5.0e-6,
|
|
Cv: float = 0.5,
|
|
Kv: float = 0.4,
|
|
gi: float = 1.0,
|
|
flowset: float = 1.0,
|
|
) -> None:
|
|
super().__init__(name=name)
|
|
self.set_parameter_values(
|
|
{
|
|
"cq": cq,
|
|
"area": area,
|
|
"Cv": Cv,
|
|
"Kv": Kv,
|
|
"gi": gi,
|
|
"flowset": flowset,
|
|
}
|
|
)
|
|
self.medium = medium
|
|
self.cq = float(cq)
|
|
self.area = float(area)
|
|
self.Cv = float(Cv)
|
|
self.Kv = float(Kv)
|
|
self.gi = self._integer_parameter("gi", gi)
|
|
self.flowset = self._integer_parameter("flowset", flowset)
|
|
if self.flowset not in {1, 2, 3}:
|
|
raise ValueError("PNOR001 flowset must be 1, 2, or 3.")
|
|
|
|
initial_h = medium.specific_enthalpy(medium.T_ref)
|
|
self.port_1 = self.register_declared_port("port_1")
|
|
self.port_1.h_outflow = initial_h
|
|
self.port_2 = self.register_declared_port("port_2")
|
|
self.port_2.h_outflow = initial_h
|
|
|
|
@staticmethod
|
|
def _integer_parameter(name: str, value: float) -> int:
|
|
rounded = round(value)
|
|
if not isclose(value, rounded, rel_tol=0.0, abs_tol=1.0e-12):
|
|
raise ValueError(f"PNOR001 parameter {name} must be an integer value.")
|
|
return int(rounded)
|
|
|
|
@classmethod
|
|
def create(
|
|
cls,
|
|
*,
|
|
name: str,
|
|
medium: IdealGasMedium,
|
|
parameters: Mapping[str, float],
|
|
) -> AmesimPnor001:
|
|
return cls(
|
|
name=name,
|
|
medium=medium,
|
|
cq=parameters["cq"],
|
|
area=parameters["area"],
|
|
Cv=parameters["Cv"],
|
|
Kv=parameters["Kv"],
|
|
gi=parameters["gi"],
|
|
flowset=parameters["flowset"],
|
|
)
|
|
|
|
@property
|
|
def effective_cq(self) -> float:
|
|
return self.cq if self.flowset == 1 else 0.72
|
|
|
|
@property
|
|
def effective_area(self) -> float:
|
|
if self.flowset == 1:
|
|
return self.area
|
|
if self.flowset == 2:
|
|
return self._area_from_cv(self.Cv, self.effective_cq)
|
|
return self._area_from_kv(self.Kv, self.effective_cq)
|
|
|
|
@staticmethod
|
|
def _area_from_cv(Cv: float, cq: float) -> float:
|
|
water_density = 999.0
|
|
reference_flow_m3_s = Cv * 6.30901964e-5
|
|
reference_dp_pa = 6894.75729
|
|
return reference_flow_m3_s / (cq * sqrt(2.0 * reference_dp_pa / water_density))
|
|
|
|
@staticmethod
|
|
def _area_from_kv(Kv: float, cq: float) -> float:
|
|
water_density = 999.0
|
|
reference_flow_m3_s = Kv / 3600.0
|
|
reference_dp_pa = 100000.0
|
|
return reference_flow_m3_s / (cq * sqrt(2.0 * reference_dp_pa / water_density))
|
|
|
|
def _upstream_temperature(self, port_name: str) -> float:
|
|
port = self.get_port(port_name)
|
|
if port.h_outflow > 0.0:
|
|
return max(port.h_outflow / self.medium.cp_ref, 1.0)
|
|
return self.medium.T_ref
|
|
|
|
def mass_flow(self, p_1: float, p_2: float) -> float:
|
|
if p_1 == p_2 or self.effective_area == 0.0:
|
|
return 0.0
|
|
if p_1 > p_2:
|
|
return self._one_way_mass_flow(
|
|
upstream_pressure=p_1,
|
|
downstream_pressure=p_2,
|
|
upstream_temperature=self._upstream_temperature("port_1"),
|
|
)
|
|
return -self._one_way_mass_flow(
|
|
upstream_pressure=p_2,
|
|
downstream_pressure=p_1,
|
|
upstream_temperature=self._upstream_temperature("port_2"),
|
|
)
|
|
|
|
def _one_way_mass_flow(
|
|
self,
|
|
*,
|
|
upstream_pressure: float,
|
|
downstream_pressure: float,
|
|
upstream_temperature: float,
|
|
) -> float:
|
|
p_up = max(upstream_pressure, 1.0)
|
|
p_down = max(min(downstream_pressure, p_up), 0.0)
|
|
T_up = max(upstream_temperature, 1.0)
|
|
gamma = max(self.medium.gamma, 1.000001)
|
|
pressure_ratio = max(p_down / p_up, 0.0)
|
|
critical_ratio = (2.0 / (gamma + 1.0)) ** (gamma / (gamma - 1.0))
|
|
if pressure_ratio <= critical_ratio:
|
|
flow_factor = sqrt(gamma / (self.medium.R_gas * T_up)) * (
|
|
2.0 / (gamma + 1.0)
|
|
) ** ((gamma + 1.0) / (2.0 * (gamma - 1.0)))
|
|
else:
|
|
expansion = pressure_ratio ** (2.0 / gamma) - pressure_ratio ** (
|
|
(gamma + 1.0) / gamma
|
|
)
|
|
flow_factor = sqrt(
|
|
max(
|
|
2.0
|
|
* gamma
|
|
* expansion
|
|
/ (self.medium.R_gas * T_up * (gamma - 1.0)),
|
|
0.0,
|
|
)
|
|
)
|
|
return self.effective_cq * self.effective_area * p_up * flow_factor
|
|
|
|
def component_result_values(self) -> Mapping[str, float]:
|
|
p_1 = max(self.port_1.p, 1.0)
|
|
p_2 = max(self.port_2.p, 1.0)
|
|
m_flow = abs(self.mass_flow(self.port_1.p, self.port_2.p))
|
|
upstream_pressure = max(p_1, p_2)
|
|
upstream_temperature = self._upstream_temperature(
|
|
"port_1" if p_1 >= p_2 else "port_2"
|
|
)
|
|
density = max(self.medium.density(upstream_pressure, upstream_temperature), 1.0e-12)
|
|
area = max(self.effective_area, 1.0e-18)
|
|
return {
|
|
"cm": m_flow / (self.effective_cq * area * upstream_pressure),
|
|
"gasvel": m_flow / (density * area),
|
|
}
|
|
|
|
def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
|
|
return (
|
|
EquationResidual(
|
|
id=f"{self.name}:mass_flow_balance",
|
|
owner="component",
|
|
owner_id=self.name,
|
|
relation="sumToZero",
|
|
variables=(
|
|
f"{self.name}.port_1.m_flow",
|
|
f"{self.name}.port_2.m_flow",
|
|
),
|
|
role="flow",
|
|
value=self.port_1.m_flow + self.port_2.m_flow,
|
|
),
|
|
EquationResidual(
|
|
id=f"{self.name}:pressure_flow_relation",
|
|
owner="component",
|
|
owner_id=self.name,
|
|
relation="constitutive",
|
|
variables=(
|
|
f"{self.name}.port_1.p",
|
|
f"{self.name}.port_2.p",
|
|
f"{self.name}.port_1.m_flow",
|
|
),
|
|
role="flow",
|
|
value=self.port_1.m_flow
|
|
- self.mass_flow(self.port_1.p, self.port_2.p),
|
|
),
|
|
)
|
|
|
|
def update_stream_outflows(self, connected_h: Mapping[str, float]) -> None:
|
|
self.port_1.h_outflow = connected_h["port_2"]
|
|
self.port_2.h_outflow = connected_h["port_1"]
|
|
|
|
|
|
class AmesimPnvo001FixedOpening(AlgebraicComponent):
|
|
"""Fixed-opening public variant of AMESim PNVO001.
|
|
|
|
Full PNVO001 has a signal input port. The current public component library
|
|
does not support signal simulation, so this model exposes the pneumatic
|
|
ports and replaces the signal with a normalized `opening` parameter.
|
|
"""
|
|
|
|
MODEL_TYPE = "amesim_pnvo001_fixed"
|
|
MODEL_VERSION = "0.1.0"
|
|
PORTS = (
|
|
PortDefinition.pneumatic("port_2", nominal_role="bidirectional"),
|
|
PortDefinition.pneumatic("port_3", nominal_role="bidirectional"),
|
|
)
|
|
PARAMETERS = (
|
|
ParameterDefinition(
|
|
"cq",
|
|
0.72,
|
|
label="流量系数 Cq",
|
|
quantity="dimensionless",
|
|
unit="",
|
|
minimum=1.0e-10,
|
|
maximum=1.0,
|
|
),
|
|
ParameterDefinition(
|
|
"area0",
|
|
5.0e-6,
|
|
label="最大孔口面积",
|
|
quantity="area",
|
|
unit="m2",
|
|
minimum=0.0,
|
|
maximum=1.0,
|
|
),
|
|
ParameterDefinition(
|
|
"Cv",
|
|
0.5,
|
|
label="最大流量系数 Cv",
|
|
quantity="dimensionless",
|
|
unit="",
|
|
minimum=0.0,
|
|
),
|
|
ParameterDefinition(
|
|
"Kv",
|
|
0.4,
|
|
label="最大流量系数 Kv",
|
|
quantity="dimensionless",
|
|
unit="",
|
|
minimum=0.0,
|
|
),
|
|
ParameterDefinition(
|
|
"gi",
|
|
1.0,
|
|
label="气体类型索引",
|
|
quantity="dimensionless",
|
|
unit="",
|
|
minimum=1.0,
|
|
maximum=99.0,
|
|
),
|
|
ParameterDefinition(
|
|
"flowset",
|
|
1.0,
|
|
label="流量系数设置",
|
|
quantity="dimensionless",
|
|
unit="",
|
|
minimum=1.0,
|
|
maximum=3.0,
|
|
),
|
|
ParameterDefinition(
|
|
"opening",
|
|
1.0,
|
|
label="固定开度",
|
|
quantity="dimensionless",
|
|
unit="",
|
|
minimum=0.0,
|
|
maximum=1.0,
|
|
),
|
|
)
|
|
RESULT_VARIABLES = (
|
|
ResultVariableDefinition(
|
|
"xv",
|
|
label="有效开度",
|
|
quantity="dimensionless",
|
|
unit="",
|
|
category="derived",
|
|
order=10,
|
|
),
|
|
ResultVariableDefinition(
|
|
"cm",
|
|
label="质量流量参数",
|
|
quantity="dimensionless",
|
|
unit="",
|
|
category="derived",
|
|
order=20,
|
|
),
|
|
ResultVariableDefinition(
|
|
"gasvel",
|
|
label="缩流截面气体速度",
|
|
quantity="velocity",
|
|
unit="m/s",
|
|
category="derived",
|
|
order=30,
|
|
),
|
|
)
|
|
DISPLAY = ComponentDisplaySpec(
|
|
label="PNVO001 固定开度气动孔口",
|
|
library_id="amesim",
|
|
category_id="flow",
|
|
symbol="orifice",
|
|
ports=(
|
|
PortDisplaySpec("port_2", "left", order=10),
|
|
PortDisplaySpec("port_3", "right", order=20),
|
|
),
|
|
order=30,
|
|
)
|
|
|
|
def __init__(
|
|
self,
|
|
name: str,
|
|
medium: IdealGasMedium,
|
|
*,
|
|
cq: float = 0.72,
|
|
area0: float = 5.0e-6,
|
|
Cv: float = 0.5,
|
|
Kv: float = 0.4,
|
|
gi: float = 1.0,
|
|
flowset: float = 1.0,
|
|
opening: float = 1.0,
|
|
) -> None:
|
|
super().__init__(name=name)
|
|
self.set_parameter_values(
|
|
{
|
|
"cq": cq,
|
|
"area0": area0,
|
|
"Cv": Cv,
|
|
"Kv": Kv,
|
|
"gi": gi,
|
|
"flowset": flowset,
|
|
"opening": opening,
|
|
}
|
|
)
|
|
self.medium = medium
|
|
self.cq = float(cq)
|
|
self.area0 = float(area0)
|
|
self.Cv = float(Cv)
|
|
self.Kv = float(Kv)
|
|
self.gi = self._integer_parameter("gi", gi)
|
|
self.flowset = self._integer_parameter("flowset", flowset)
|
|
if self.flowset not in {1, 2, 3}:
|
|
raise ValueError("PNVO001 fixed-opening flowset must be 1, 2, or 3.")
|
|
self.opening = min(1.0, max(0.0, float(opening)))
|
|
|
|
initial_h = medium.specific_enthalpy(medium.T_ref)
|
|
self.port_2 = self.register_declared_port("port_2")
|
|
self.port_2.h_outflow = initial_h
|
|
self.port_3 = self.register_declared_port("port_3")
|
|
self.port_3.h_outflow = initial_h
|
|
|
|
@staticmethod
|
|
def _integer_parameter(name: str, value: float) -> int:
|
|
rounded = round(value)
|
|
if not isclose(value, rounded, rel_tol=0.0, abs_tol=1.0e-12):
|
|
raise ValueError(f"PNVO001 fixed-opening parameter {name} must be an integer value.")
|
|
return int(rounded)
|
|
|
|
@classmethod
|
|
def create(
|
|
cls,
|
|
*,
|
|
name: str,
|
|
medium: IdealGasMedium,
|
|
parameters: Mapping[str, float],
|
|
) -> AmesimPnvo001FixedOpening:
|
|
return cls(
|
|
name=name,
|
|
medium=medium,
|
|
cq=parameters["cq"],
|
|
area0=parameters["area0"],
|
|
Cv=parameters["Cv"],
|
|
Kv=parameters["Kv"],
|
|
gi=parameters["gi"],
|
|
flowset=parameters["flowset"],
|
|
opening=parameters["opening"],
|
|
)
|
|
|
|
@property
|
|
def effective_cq(self) -> float:
|
|
return self.cq if self.flowset == 1 else 0.72
|
|
|
|
@property
|
|
def maximum_area(self) -> float:
|
|
if self.flowset == 1:
|
|
return self.area0
|
|
if self.flowset == 2:
|
|
return AmesimPnor001._area_from_cv(self.Cv, self.effective_cq)
|
|
return AmesimPnor001._area_from_kv(self.Kv, self.effective_cq)
|
|
|
|
@property
|
|
def effective_area(self) -> float:
|
|
return self.opening * self.maximum_area
|
|
|
|
def _upstream_temperature(self, port_name: str) -> float:
|
|
port = self.get_port(port_name)
|
|
if port.h_outflow > 0.0:
|
|
return max(port.h_outflow / self.medium.cp_ref, 1.0)
|
|
return self.medium.T_ref
|
|
|
|
def mass_flow(self, p_2: float, p_3: float) -> float:
|
|
if p_2 == p_3 or self.effective_area == 0.0:
|
|
return 0.0
|
|
if p_2 > p_3:
|
|
return self._one_way_mass_flow(
|
|
upstream_pressure=p_2,
|
|
downstream_pressure=p_3,
|
|
upstream_temperature=self._upstream_temperature("port_2"),
|
|
)
|
|
return -self._one_way_mass_flow(
|
|
upstream_pressure=p_3,
|
|
downstream_pressure=p_2,
|
|
upstream_temperature=self._upstream_temperature("port_3"),
|
|
)
|
|
|
|
def _one_way_mass_flow(
|
|
self,
|
|
*,
|
|
upstream_pressure: float,
|
|
downstream_pressure: float,
|
|
upstream_temperature: float,
|
|
) -> float:
|
|
p_up = max(upstream_pressure, 1.0)
|
|
p_down = max(min(downstream_pressure, p_up), 0.0)
|
|
T_up = max(upstream_temperature, 1.0)
|
|
gamma = max(self.medium.gamma, 1.000001)
|
|
pressure_ratio = max(p_down / p_up, 0.0)
|
|
critical_ratio = (2.0 / (gamma + 1.0)) ** (gamma / (gamma - 1.0))
|
|
if pressure_ratio <= critical_ratio:
|
|
flow_factor = sqrt(gamma / (self.medium.R_gas * T_up)) * (
|
|
2.0 / (gamma + 1.0)
|
|
) ** ((gamma + 1.0) / (2.0 * (gamma - 1.0)))
|
|
else:
|
|
expansion = pressure_ratio ** (2.0 / gamma) - pressure_ratio ** (
|
|
(gamma + 1.0) / gamma
|
|
)
|
|
flow_factor = sqrt(
|
|
max(
|
|
2.0
|
|
* gamma
|
|
* expansion
|
|
/ (self.medium.R_gas * T_up * (gamma - 1.0)),
|
|
0.0,
|
|
)
|
|
)
|
|
return self.effective_cq * self.effective_area * p_up * flow_factor
|
|
|
|
def component_result_values(self) -> Mapping[str, float]:
|
|
p_2 = max(self.port_2.p, 1.0)
|
|
p_3 = max(self.port_3.p, 1.0)
|
|
m_flow = abs(self.mass_flow(self.port_2.p, self.port_3.p))
|
|
upstream_pressure = max(p_2, p_3)
|
|
upstream_temperature = self._upstream_temperature(
|
|
"port_2" if p_2 >= p_3 else "port_3"
|
|
)
|
|
density = max(self.medium.density(upstream_pressure, upstream_temperature), 1.0e-12)
|
|
area = max(self.effective_area, 1.0e-18)
|
|
return {
|
|
"xv": self.opening,
|
|
"cm": m_flow / (self.effective_cq * area * upstream_pressure),
|
|
"gasvel": m_flow / (density * area),
|
|
}
|
|
|
|
def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
|
|
return (
|
|
EquationResidual(
|
|
id=f"{self.name}:mass_flow_balance",
|
|
owner="component",
|
|
owner_id=self.name,
|
|
relation="sumToZero",
|
|
variables=(
|
|
f"{self.name}.port_2.m_flow",
|
|
f"{self.name}.port_3.m_flow",
|
|
),
|
|
role="flow",
|
|
value=self.port_2.m_flow + self.port_3.m_flow,
|
|
),
|
|
EquationResidual(
|
|
id=f"{self.name}:pressure_flow_relation",
|
|
owner="component",
|
|
owner_id=self.name,
|
|
relation="constitutive",
|
|
variables=(
|
|
f"{self.name}.port_2.p",
|
|
f"{self.name}.port_3.p",
|
|
f"{self.name}.port_2.m_flow",
|
|
),
|
|
role="flow",
|
|
value=self.port_2.m_flow
|
|
- self.mass_flow(self.port_2.p, self.port_3.p),
|
|
),
|
|
)
|
|
|
|
def update_stream_outflows(self, connected_h: Mapping[str, float]) -> None:
|
|
self.port_2.h_outflow = connected_h["port_3"]
|
|
self.port_3.h_outflow = connected_h["port_2"]
|