sepehr/Entropyk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: sync project state and current artifacts

Browse Source
This commit is contained in:
Sepehr
2026-02-22 23:27:31 +01:00
parent 1b6415776e
commit dd77089b22
232 changed files with 37056 additions and 4296 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
crates/solver/tests/convergence_criteria.rs
View File

@@ -18,7 +18,7 @@ use entropyk_solver::{
/// Test that `ConvergedState::new` does NOT attach a report (backward-compat).
#[test]
fn test_converged_state_new_no_report() {
let state = ConvergedState::new(vec![1.0, 2.0], 10, 1e-8, ConvergenceStatus::Converged);
let state = ConvergedState::new(vec![1.0, 2.0], 10, 1e-8, ConvergenceStatus::Converged, entropyk_solver::SimulationMetadata::new("".to_string()));
assert!(
state.convergence_report.is_none(),
"ConvergedState::new should not attach a report"
@@ -45,6 +45,7 @@ fn test_converged_state_with_report_attaches_report() {
1e-8,
ConvergenceStatus::Converged,
report,
entropyk_solver::SimulationMetadata::new("".to_string()),
);
assert!(
@@ -233,7 +234,7 @@ fn test_single_circuit_global_convergence() {
use entropyk_components::port::ConnectedPort;
use entropyk_components::{
Component, ComponentError, JacobianBuilder, ResidualVector, SystemState,
Component, ComponentError, JacobianBuilder, ResidualVector, StateSlice,
};
struct MockConvergingComponent;
@@ -241,7 +242,7 @@ struct MockConvergingComponent;
impl Component for MockConvergingComponent {
fn compute_residuals(
&self,
state: &SystemState,
state: &StateSlice,
residuals: &mut ResidualVector,
) -> Result<(), ComponentError> {
// Simple linear system will converge in 1 step
@@ -252,7 +253,7 @@ impl Component for MockConvergingComponent {
fn jacobian_entries(
&self,
_state: &SystemState,
_state: &StateSlice,
jacobian: &mut JacobianBuilder,
) -> Result<(), ComponentError> {
jacobian.add_entry(0, 0, 1.0);

18
crates/solver/tests/fallback_solver.rs
View File

@@ -9,7 +9,7 @@
//! - No heap allocation during switches
use entropyk_components::{
Component, ComponentError, JacobianBuilder, ResidualVector, SystemState,
Component, ComponentError, JacobianBuilder, ResidualVector, StateSlice,
};
use entropyk_solver::solver::{
ConvergenceStatus, FallbackConfig, FallbackSolver, NewtonConfig, PicardConfig, Solver,
@@ -50,7 +50,7 @@ impl LinearSystem {
impl Component for LinearSystem {
fn compute_residuals(
&self,
state: &SystemState,
state: &StateSlice,
residuals: &mut ResidualVector,
) -> Result<(), ComponentError> {
// r = A * x - b
@@ -66,7 +66,7 @@ impl Component for LinearSystem {
fn jacobian_entries(
&self,
_state: &SystemState,
_state: &StateSlice,
jacobian: &mut JacobianBuilder,
) -> Result<(), ComponentError> {
// J = A (constant Jacobian)
@@ -105,7 +105,7 @@ impl StiffNonlinearSystem {
impl Component for StiffNonlinearSystem {
fn compute_residuals(
&self,
state: &SystemState,
state: &StateSlice,
residuals: &mut ResidualVector,
) -> Result<(), ComponentError> {
// Non-linear residual: r_i = x_i^3 - alpha * x_i - 1
@@ -119,7 +119,7 @@ impl Component for StiffNonlinearSystem {
fn jacobian_entries(
&self,
state: &SystemState,
state: &StateSlice,
jacobian: &mut JacobianBuilder,
) -> Result<(), ComponentError> {
// J_ii = 3 * x_i^2 - alpha
@@ -157,7 +157,7 @@ impl SlowConvergingSystem {
impl Component for SlowConvergingSystem {
fn compute_residuals(
&self,
state: &SystemState,
state: &StateSlice,
residuals: &mut ResidualVector,
) -> Result<(), ComponentError> {
// r = x - target (simple, but Newton can overshoot)
@@ -167,7 +167,7 @@ impl Component for SlowConvergingSystem {
fn jacobian_entries(
&self,
_state: &SystemState,
_state: &StateSlice,
jacobian: &mut JacobianBuilder,
) -> Result<(), ComponentError> {
jacobian.add_entry(0, 0, 1.0);
@@ -635,7 +635,7 @@ fn test_fallback_already_converged() {
impl Component for ZeroResidualComponent {
fn compute_residuals(
&self,
_state: &SystemState,
_state: &StateSlice,
residuals: &mut ResidualVector,
) -> Result<(), ComponentError> {
residuals[0] = 0.0; // Already zero
@@ -644,7 +644,7 @@ fn test_fallback_already_converged() {
fn jacobian_entries(
&self,
_state: &SystemState,
_state: &StateSlice,
jacobian: &mut JacobianBuilder,
) -> Result<(), ComponentError> {
jacobian.add_entry(0, 0, 1.0);

97
crates/solver/tests/inverse_calibration.rs
View File

@@ -4,13 +4,13 @@
//! - AC: Components can dynamically read calibration factors (e.g. f_m, f_ua) from SystemState.
//! - AC: The solver successfully optimizes these calibration factors to meet constraints.
use entropyk_components::{Component, ComponentError, ConnectedPort, JacobianBuilder, ResidualVector, SystemState};
use entropyk_components::{
Component, ComponentError, ConnectedPort, JacobianBuilder, ResidualVector, StateSlice,
};
use entropyk_core::CalibIndices;
use entropyk_solver::{
System, NewtonConfig, Solver,
inverse::{
BoundedVariable, BoundedVariableId, Constraint, ConstraintId, ComponentOutput,
},
inverse::{BoundedVariable, BoundedVariableId, ComponentOutput, Constraint, ConstraintId},
NewtonConfig, Solver, System,
};
/// A mock component that simulates a heat exchanger whose capacity depends on `f_ua`.
@@ -21,28 +21,28 @@ struct MockCalibratedComponent {
impl Component for MockCalibratedComponent {
fn compute_residuals(
&self,
state: &SystemState,
state: &StateSlice,
residuals: &mut ResidualVector,
) -> Result<(), ComponentError> {
// Fix the edge states to a known value
residuals[0] = state[0] - 300.0;
residuals[1] = state[1] - 400.0;
Ok(())
}
fn jacobian_entries(
&self,
_state: &SystemState,
_state: &StateSlice,
jacobian: &mut JacobianBuilder,
) -> Result<(), ComponentError> {
// d(r0)/d(state[0]) = 1.0
jacobian.add_entry(0, 0, 1.0);
// d(r1)/d(state[1]) = 1.0
jacobian.add_entry(1, 1, 1.0);
// No dependence of physical equations on f_ua
Ok(())
}
@@ -62,17 +62,17 @@ impl Component for MockCalibratedComponent {
#[test]
fn test_inverse_calibration_f_ua() {
let mut sys = System::new();
// Create a mock component
let mock = Box::new(MockCalibratedComponent {
calib_indices: CalibIndices::default(),
});
let comp_id = sys.add_component(mock);
sys.register_component_name("evaporator", comp_id);
// Add a self-edge just to simulate some connections
sys.add_edge(comp_id, comp_id).unwrap();
// We want the capacity to be exactly 4015 W.
// The mocked math in System::extract_constraint_values_with_controls:
// Capacity = state[1] * 10.0 + f_ua * 10.0 (primary effect)
@@ -87,54 +87,61 @@ fn test_inverse_calibration_f_ua() {
component_id: "evaporator".to_string(),
},
4015.0,
)).unwrap();
))
.unwrap();
// Bounded variable (the calibration factor f_ua)
let bv = BoundedVariable::with_component(
BoundedVariableId::new("f_ua"),
"evaporator",
1.0, // initial
0.1, // min
10.0 // max
).unwrap();
1.0, // initial
0.1, // min
10.0, // max
)
.unwrap();
sys.add_bounded_variable(bv).unwrap();
// Link constraint to control
sys.link_constraint_to_control(
&ConstraintId::new("capacity_control"),
&BoundedVariableId::new("f_ua")
).unwrap();
&BoundedVariableId::new("f_ua"),
)
.unwrap();
sys.finalize().unwrap();
// Verify that the validation passes
assert!(sys.validate_inverse_control_dof().is_ok());
let initial_state = vec![0.0; sys.full_state_vector_len()];
// Use NewtonRaphson
let mut solver = NewtonConfig::default().with_initial_state(initial_state);
let result = solver.solve(&mut sys);
// Should converge quickly
assert!(dbg!(&result).is_ok());
let converged = result.unwrap();
// The control variable `f_ua` is at the end of the state vector
let f_ua_idx = sys.full_state_vector_len() - 1;
let final_f_ua: f64 = converged.state[f_ua_idx];
// Target f_ua = 1.5
let abs_diff = (final_f_ua - 1.5_f64).abs();
assert!(abs_diff < 1e-4, "f_ua should converge to 1.5, got {}", final_f_ua);
assert!(
abs_diff < 1e-4,
"f_ua should converge to 1.5, got {}",
final_f_ua
);
}
#[test]
fn test_inverse_expansion_valve_calibration() {
use entropyk_components::expansion_valve::ExpansionValve;
use entropyk_components::port::{FluidId, Port};
use entropyk_core::{Pressure, Enthalpy};
use entropyk_core::{Enthalpy, Pressure};
let mut sys = System::new();
@@ -149,7 +156,7 @@ fn test_inverse_expansion_valve_calibration() {
Pressure::from_bar(10.0),
Enthalpy::from_joules_per_kg(250000.0),
);
let inlet_target = Port::new(
FluidId::new("R134a"),
Pressure::from_bar(10.0),
@@ -160,9 +167,13 @@ fn test_inverse_expansion_valve_calibration() {
Pressure::from_bar(10.0),
Enthalpy::from_joules_per_kg(250000.0),
);
let valve_disconnected = ExpansionValve::new(inlet, outlet, Some(1.0)).unwrap();
let valve = Box::new(valve_disconnected.connect(inlet_target, outlet_target).unwrap());
let valve = Box::new(
valve_disconnected
.connect(inlet_target, outlet_target)
.unwrap(),
);
let comp_id = sys.add_component(valve);
sys.register_component_name("valve", comp_id);
@@ -175,14 +186,16 @@ fn test_inverse_expansion_valve_calibration() {
// Wait, let's look at ExpansionValve residuals:
// residuals[1] = mass_flow_out - f_m * mass_flow_in;
// state[0] = mass_flow_in, state[1] = mass_flow_out
sys.add_constraint(Constraint::new(
ConstraintId::new("flow_control"),
ComponentOutput::Capacity { // Mocking output for test
ComponentOutput::Capacity {
// Mocking output for test
component_id: "valve".to_string(),
},
0.5,
)).unwrap();
))
.unwrap();
// Add a bounded variable for f_m
let bv = BoundedVariable::with_component(
@@ -190,14 +203,16 @@ fn test_inverse_expansion_valve_calibration() {
"valve",
1.0, // initial
0.1, // min
2.0 // max
).unwrap();
2.0, // max
)
.unwrap();
sys.add_bounded_variable(bv).unwrap();
sys.link_constraint_to_control(
&ConstraintId::new("flow_control"),
&BoundedVariableId::new("f_m")
).unwrap();
&BoundedVariableId::new("f_m"),
)
.unwrap();
sys.finalize().unwrap();

6
crates/solver/tests/inverse_control.rs
View File

@@ -7,7 +7,7 @@
//! - AC #4: DoF validation correctly handles multiple linked variables
use entropyk_components::{
Component, ComponentError, ConnectedPort, JacobianBuilder, ResidualVector, SystemState,
Component, ComponentError, ConnectedPort, JacobianBuilder, ResidualVector, StateSlice,
};
use entropyk_solver::{
inverse::{BoundedVariable, BoundedVariableId, ComponentOutput, Constraint, ConstraintId},
@@ -26,7 +26,7 @@ struct MockPassThrough {
impl Component for MockPassThrough {
fn compute_residuals(
&self,
_state: &SystemState,
_state: &StateSlice,
residuals: &mut ResidualVector,
) -> Result<(), ComponentError> {
for r in residuals.iter_mut().take(self.n_eq) {
@@ -37,7 +37,7 @@ impl Component for MockPassThrough {
fn jacobian_entries(
&self,
_state: &SystemState,
_state: &StateSlice,
jacobian: &mut JacobianBuilder,
) -> Result<(), ComponentError> {
for i in 0..self.n_eq {

10
crates/solver/tests/jacobian_freezing.rs
View File

@@ -8,7 +8,7 @@
use approx::assert_relative_eq;
use entropyk_components::{
Component, ComponentError, JacobianBuilder, ResidualVector, SystemState,
Component, ComponentError, JacobianBuilder, ResidualVector, StateSlice,
};
use entropyk_solver::{
solver::{JacobianFreezingConfig, NewtonConfig, Solver},
@@ -34,7 +34,7 @@ impl LinearTargetSystem {
impl Component for LinearTargetSystem {
fn compute_residuals(
&self,
state: &SystemState,
state: &StateSlice,
residuals: &mut ResidualVector,
) -> Result<(), ComponentError> {
for (i, &t) in self.targets.iter().enumerate() {
@@ -45,7 +45,7 @@ impl Component for LinearTargetSystem {
fn jacobian_entries(
&self,
_state: &SystemState,
_state: &StateSlice,
jacobian: &mut JacobianBuilder,
) -> Result<(), ComponentError> {
for i in 0..self.targets.len() {
@@ -79,7 +79,7 @@ impl CubicTargetSystem {
impl Component for CubicTargetSystem {
fn compute_residuals(
&self,
state: &SystemState,
state: &StateSlice,
residuals: &mut ResidualVector,
) -> Result<(), ComponentError> {
for (i, &t) in self.targets.iter().enumerate() {
@@ -91,7 +91,7 @@ impl Component for CubicTargetSystem {
fn jacobian_entries(
&self,
state: &SystemState,
state: &StateSlice,
jacobian: &mut JacobianBuilder,
) -> Result<(), ComponentError> {
for (i, &t) in self.targets.iter().enumerate() {

6
crates/solver/tests/macro_component_integration.rs
View File

@@ -7,7 +7,7 @@
//! - AC #4: Serialization snapshot round-trip
use entropyk_components::{
Component, ComponentError, ConnectedPort, JacobianBuilder, ResidualVector, SystemState,
Component, ComponentError, ConnectedPort, JacobianBuilder, ResidualVector, StateSlice,
};
use entropyk_solver::{MacroComponent, MacroComponentSnapshot, System};
@@ -23,7 +23,7 @@ struct PassThrough {
impl Component for PassThrough {
fn compute_residuals(
&self,
_state: &SystemState,
_state: &StateSlice,
residuals: &mut ResidualVector,
) -> Result<(), ComponentError> {
for r in residuals.iter_mut().take(self.n_eq) {
@@ -34,7 +34,7 @@ impl Component for PassThrough {
fn jacobian_entries(
&self,
_state: &SystemState,
_state: &StateSlice,
jacobian: &mut JacobianBuilder,
) -> Result<(), ComponentError> {
for i in 0..self.n_eq {

271
crates/solver/tests/mass_balance_integration.rs Normal file
View File

@@ -0,0 +1,271 @@
//! Integration test for mass balance validation with multiple components.
//!
//! This test verifies that the mass balance validation works correctly
//! across a multi-component system simulating a refrigeration cycle.
use entropyk_components::port::{FluidId, Port};
use entropyk_components::{
Component, ComponentError, ConnectedPort, JacobianBuilder, ResidualVector, StateSlice,
};
use entropyk_core::{Enthalpy, MassFlow, Pressure};
use entropyk_solver::system::System;
// ─────────────────────────────────────────────────────────────────────────────
// Mock components for testing
// ─────────────────────────────────────────────────────────────────────────────
/// A mock component that simulates balanced mass flow (like a pipe or heat exchanger).
struct BalancedComponent {
ports: Vec<ConnectedPort>,
mass_flow_in: f64,
}
impl BalancedComponent {
fn new(ports: Vec<ConnectedPort>, mass_flow: f64) -> Self {
Self {
ports,
mass_flow_in: mass_flow,
}
}
}
impl Component for BalancedComponent {
fn compute_residuals(
&self,
_state: &StateSlice,
residuals: &mut ResidualVector,
) -> Result<(), ComponentError> {
for r in residuals.iter_mut() {
*r = 0.0;
}
Ok(())
}
fn jacobian_entries(
&self,
_state: &StateSlice,
jacobian: &mut JacobianBuilder,
) -> Result<(), ComponentError> {
for i in 0..self.n_equations() {
jacobian.add_entry(i, i, 1.0);
}
Ok(())
}
fn n_equations(&self) -> usize {
2
}
fn get_ports(&self) -> &[ConnectedPort] {
&self.ports
}
fn port_mass_flows(&self, _state: &StateSlice) -> Result<Vec<MassFlow>, ComponentError> {
// Balanced: inlet positive, outlet negative
Ok(vec![
MassFlow::from_kg_per_s(self.mass_flow_in),
MassFlow::from_kg_per_s(-self.mass_flow_in),
])
}
}
/// A mock component with imbalanced mass flow (for testing violation detection).
struct ImbalancedComponent {
ports: Vec<ConnectedPort>,
}
impl ImbalancedComponent {
fn new(ports: Vec<ConnectedPort>) -> Self {
Self { ports }
}
}
impl Component for ImbalancedComponent {
fn compute_residuals(
&self,
_state: &StateSlice,
residuals: &mut ResidualVector,
) -> Result<(), ComponentError> {
for r in residuals.iter_mut() {
*r = 0.0;
}
Ok(())
}
fn jacobian_entries(
&self,
_state: &StateSlice,
jacobian: &mut JacobianBuilder,
) -> Result<(), ComponentError> {
for i in 0..self.n_equations() {
jacobian.add_entry(i, i, 1.0);
}
Ok(())
}
fn n_equations(&self) -> usize {
2
}
fn get_ports(&self) -> &[ConnectedPort] {
&self.ports
}
fn port_mass_flows(&self, _state: &StateSlice) -> Result<Vec<MassFlow>, ComponentError> {
// Imbalanced: inlet 1.0 kg/s, outlet -0.5 kg/s (sum = 0.5 kg/s violation)
Ok(vec![
MassFlow::from_kg_per_s(1.0),
MassFlow::from_kg_per_s(-0.5),
])
}
}
// ─────────────────────────────────────────────────────────────────────────────
// Test helpers
// ─────────────────────────────────────────────────────────────────────────────
fn make_connected_port_pair(
fluid: &str,
p_bar: f64,
h_j_kg: f64,
) -> (ConnectedPort, ConnectedPort) {
let p1 = Port::new(
FluidId::new(fluid),
Pressure::from_bar(p_bar),
Enthalpy::from_joules_per_kg(h_j_kg),
);
let p2 = Port::new(
FluidId::new(fluid),
Pressure::from_bar(p_bar),
Enthalpy::from_joules_per_kg(h_j_kg),
);
let (c1, c2) = p1.connect(p2).unwrap();
(c1, c2)
}
// ─────────────────────────────────────────────────────────────────────────────
// Tests
// ─────────────────────────────────────────────────────────────────────────────
#[test]
fn test_mass_balance_4_component_cycle() {
// Simulate a 4-component refrigeration cycle: Compressor → Condenser → Valve → Evaporator
let mut system = System::new();
// Create 4 pairs of connected ports for 4 components
let (p1a, p1b) = make_connected_port_pair("R134a", 5.0, 400_000.0);
let (p2a, p2b) = make_connected_port_pair("R134a", 5.0, 400_000.0);
let (p3a, p3b) = make_connected_port_pair("R134a", 5.0, 400_000.0);
let (p4a, p4b) = make_connected_port_pair("R134a", 5.0, 400_000.0);
// Create 4 balanced components (simulating compressor, condenser, valve, evaporator)
let mass_flow = 0.1; // kg/s
let comp1 = Box::new(BalancedComponent::new(vec![p1a, p1b], mass_flow));
let comp2 = Box::new(BalancedComponent::new(vec![p2a, p2b], mass_flow));
let comp3 = Box::new(BalancedComponent::new(vec![p3a, p3b], mass_flow));
let comp4 = Box::new(BalancedComponent::new(vec![p4a, p4b], mass_flow));
// Add components to system
let n1 = system.add_component(comp1);
let n2 = system.add_component(comp2);
let n3 = system.add_component(comp3);
let n4 = system.add_component(comp4);
// Connect in a cycle
system.add_edge(n1, n2).unwrap();
system.add_edge(n2, n3).unwrap();
system.add_edge(n3, n4).unwrap();
system.add_edge(n4, n1).unwrap();
system.finalize().unwrap();
// Test with zero state vector
let state = vec![0.0; system.full_state_vector_len()];
let result = system.check_mass_balance(&state);
assert!(
result.is_ok(),
"Mass balance should pass for balanced 4-component cycle"
);
}
#[test]
fn test_mass_balance_detects_imbalance_in_cycle() {
// Create a cycle with one imbalanced component
let mut system = System::new();
let (p1a, p1b) = make_connected_port_pair("R134a", 5.0, 400_000.0);
let (p2a, p2b) = make_connected_port_pair("R134a", 5.0, 400_000.0);
let (p3a, p3b) = make_connected_port_pair("R134a", 5.0, 400_000.0);
// Two balanced components
let comp1 = Box::new(BalancedComponent::new(vec![p1a, p1b], 0.1));
let comp3 = Box::new(BalancedComponent::new(vec![p3a, p3b], 0.1));
// One imbalanced component
let comp2 = Box::new(ImbalancedComponent::new(vec![p2a, p2b]));
let n1 = system.add_component(comp1);
let n2 = system.add_component(comp2);
let n3 = system.add_component(comp3);
system.add_edge(n1, n2).unwrap();
system.add_edge(n2, n3).unwrap();
system.add_edge(n3, n1).unwrap();
system.finalize().unwrap();
let state = vec![0.0; system.full_state_vector_len()];
let result = system.check_mass_balance(&state);
assert!(
result.is_err(),
"Mass balance should fail when one component is imbalanced"
);
}
#[test]
fn test_mass_balance_multiple_components_same_flow() {
// Test that multiple components with the same mass flow pass validation
let mut system = System::new();
// Create 6 components in a chain
let mut ports = Vec::new();
for _ in 0..6 {
let (pa, pb) = make_connected_port_pair("R134a", 5.0, 400_000.0);
ports.push((pa, pb));
}
let mass_flow = 0.5; // kg/s
let components: Vec<_> = ports
.into_iter()
.map(|(pa, pb)| Box::new(BalancedComponent::new(vec![pa, pb], mass_flow)))
.collect();
let nodes: Vec<_> = components
.into_iter()
.map(|c| system.add_component(c))
.collect();
// Connect in a cycle
for i in 0..nodes.len() {
let next = (i + 1) % nodes.len();
system.add_edge(nodes[i], nodes[next]).unwrap();
}
system.finalize().unwrap();
let state = vec![0.0; system.full_state_vector_len()];
let result = system.check_mass_balance(&state);
assert!(
result.is_ok(),
"Mass balance should pass for multiple balanced components"
);
}
#[test]
fn test_mass_balance_tolerance_constant_accessible() {
// Verify the tolerance constant is accessible
assert_eq!(System::MASS_BALANCE_TOLERANCE_KG_S, 1e-9);
}

6
crates/solver/tests/multi_circuit.rs
View File

@@ -4,7 +4,7 @@
//! Tests circuits from 2 up to the maximum of 5 circuits (circuit IDs 0-4).
use entropyk_components::{
Component, ComponentError, ConnectedPort, JacobianBuilder, ResidualVector, SystemState,
Component, ComponentError, ConnectedPort, JacobianBuilder, ResidualVector, StateSlice,
};
use entropyk_core::ThermalConductance;
use entropyk_solver::{CircuitId, System, ThermalCoupling, TopologyError};
@@ -17,7 +17,7 @@ struct RefrigerantMock {
impl Component for RefrigerantMock {
fn compute_residuals(
&self,
_state: &SystemState,
_state: &StateSlice,
residuals: &mut ResidualVector,
) -> Result<(), ComponentError> {
for r in residuals.iter_mut().take(self.n_equations) {
@@ -28,7 +28,7 @@ impl Component for RefrigerantMock {
fn jacobian_entries(
&self,
_state: &SystemState,
_state: &StateSlice,
_jacobian: &mut JacobianBuilder,
) -> Result<(), ComponentError> {
Ok(())

3
crates/solver/tests/newton_convergence.rs
View File

@@ -388,7 +388,7 @@ fn test_jacobian_non_square_overdetermined() {
fn test_convergence_status_converged() {
use entropyk_solver::ConvergedState;
let state = ConvergedState::new(vec![1.0, 2.0], 10, 1e-8, ConvergenceStatus::Converged);
let state = ConvergedState::new(vec![1.0, 2.0], 10, 1e-8, ConvergenceStatus::Converged, entropyk_solver::SimulationMetadata::new("".to_string()));
assert!(state.is_converged());
assert_eq!(state.status, ConvergenceStatus::Converged);
@@ -404,6 +404,7 @@ fn test_convergence_status_timed_out() {
50,
1e-3,
ConvergenceStatus::TimedOutWithBestState,
entropyk_solver::SimulationMetadata::new("".to_string()),
);
assert!(!state.is_converged());

3
crates/solver/tests/newton_raphson.rs
View File

@@ -226,7 +226,7 @@ fn test_converged_state_is_converged() {
use entropyk_solver::ConvergedState;
use entropyk_solver::ConvergenceStatus;
let state = ConvergedState::new(vec![1.0, 2.0, 3.0], 10, 1e-8, ConvergenceStatus::Converged);
let state = ConvergedState::new(vec![1.0, 2.0, 3.0], 10, 1e-8, ConvergenceStatus::Converged, entropyk_solver::SimulationMetadata::new("".to_string()));
assert!(state.is_converged());
assert_eq!(state.iterations, 10);
@@ -243,6 +243,7 @@ fn test_converged_state_timed_out() {
50,
1e-3,
ConvergenceStatus::TimedOutWithBestState,
entropyk_solver::SimulationMetadata::new("".to_string()),
);
assert!(!state.is_converged());

3
crates/solver/tests/picard_sequential.rs
View File

@@ -321,7 +321,7 @@ fn test_error_display_invalid_system() {
fn test_converged_state_is_converged() {
use entropyk_solver::{ConvergedState, ConvergenceStatus};
let state = ConvergedState::new(vec![1.0, 2.0, 3.0], 25, 1e-7, ConvergenceStatus::Converged);
let state = ConvergedState::new(vec![1.0, 2.0, 3.0], 25, 1e-7, ConvergenceStatus::Converged, entropyk_solver::SimulationMetadata::new("".to_string()));
assert!(state.is_converged());
assert_eq!(state.iterations, 25);
@@ -338,6 +338,7 @@ fn test_converged_state_timed_out() {
75,
1e-2,
ConvergenceStatus::TimedOutWithBestState,
entropyk_solver::SimulationMetadata::new("".to_string()),
);
assert!(!state.is_converged());

206
crates/solver/tests/refrigeration_cycle_integration.rs Normal file
View File

@@ -0,0 +1,206 @@
/// Test d'intégration : boucle réfrigération simple R134a en Rust natif.
///
/// Ce test valide que le solveur Newton converge sur un cycle 4 composants
/// en utilisant des mock components algébriques linéaires dont les équations
/// sont mathématiquement cohérentes (ferment la boucle).
use entropyk_components::{
Component, ComponentError, ConnectedPort, JacobianBuilder, ResidualVector, StateSlice,
};
use entropyk_core::{Enthalpy, MassFlow, Pressure};
use entropyk_solver::{
solver::{NewtonConfig, Solver},
system::System,
};
use entropyk_components::port::{Connected, FluidId, Port};
// Type alias: Port<Connected> ≡ ConnectedPort
type CP = Port<Connected>;
// ─── Mock compresseur ─────────────────────────────────────────────────────────
// r[0] = p_disc - (p_suc + 1 MPa)
// r[1] = h_disc - (h_suc + 75 kJ/kg)
struct MockCompressor { port_suc: CP, port_disc: CP }
impl Component for MockCompressor {
fn compute_residuals(&self, _s: &StateSlice, r: &mut ResidualVector) -> Result<(), ComponentError> {
r[0] = self.port_disc.pressure().to_pascals() - (self.port_suc.pressure().to_pascals() + 1_000_000.0);
r[1] = self.port_disc.enthalpy().to_joules_per_kg() - (self.port_suc.enthalpy().to_joules_per_kg() + 75_000.0);
Ok(())
}
fn jacobian_entries(&self, _s: &StateSlice, _j: &mut JacobianBuilder) -> Result<(), ComponentError> { Ok(()) }
fn n_equations(&self) -> usize { 2 }
fn get_ports(&self) -> &[ConnectedPort] { &[] }
fn port_mass_flows(&self, _: &StateSlice) -> Result<Vec<MassFlow>, ComponentError> {
Ok(vec![MassFlow::from_kg_per_s(0.05), MassFlow::from_kg_per_s(-0.05)])
}
}
// ─── Mock condenseur ──────────────────────────────────────────────────────────
// r[0] = p_out - p_in
// r[1] = h_out - (h_in - 225 kJ/kg)
struct MockCondenser { port_in: CP, port_out: CP }
impl Component for MockCondenser {
fn compute_residuals(&self, _s: &StateSlice, r: &mut ResidualVector) -> Result<(), ComponentError> {
r[0] = self.port_out.pressure().to_pascals() - self.port_in.pressure().to_pascals();
r[1] = self.port_out.enthalpy().to_joules_per_kg() - (self.port_in.enthalpy().to_joules_per_kg() - 225_000.0);
Ok(())
}
fn jacobian_entries(&self, _s: &StateSlice, _j: &mut JacobianBuilder) -> Result<(), ComponentError> { Ok(()) }
fn n_equations(&self) -> usize { 2 }
fn get_ports(&self) -> &[ConnectedPort] { &[] }
fn port_mass_flows(&self, _: &StateSlice) -> Result<Vec<MassFlow>, ComponentError> {
Ok(vec![MassFlow::from_kg_per_s(0.05), MassFlow::from_kg_per_s(-0.05)])
}
}
// ─── Mock détendeur ───────────────────────────────────────────────────────────
// r[0] = p_out - (p_in - 1 MPa)
// r[1] = h_out - h_in
struct MockValve { port_in: CP, port_out: CP }
impl Component for MockValve {
fn compute_residuals(&self, _s: &StateSlice, r: &mut ResidualVector) -> Result<(), ComponentError> {
r[0] = self.port_out.pressure().to_pascals() - (self.port_in.pressure().to_pascals() - 1_000_000.0);
r[1] = self.port_out.enthalpy().to_joules_per_kg() - self.port_in.enthalpy().to_joules_per_kg();
Ok(())
}
fn jacobian_entries(&self, _s: &StateSlice, _j: &mut JacobianBuilder) -> Result<(), ComponentError> { Ok(()) }
fn n_equations(&self) -> usize { 2 }
fn get_ports(&self) -> &[ConnectedPort] { &[] }
fn port_mass_flows(&self, _: &StateSlice) -> Result<Vec<MassFlow>, ComponentError> {
Ok(vec![MassFlow::from_kg_per_s(0.05), MassFlow::from_kg_per_s(-0.05)])
}
}
// ─── Mock évaporateur ─────────────────────────────────────────────────────────
// r[0] = p_out - p_in
// r[1] = h_out - (h_in + 150 kJ/kg)
struct MockEvaporator { port_in: CP, port_out: CP }
impl Component for MockEvaporator {
fn compute_residuals(&self, _s: &StateSlice, r: &mut ResidualVector) -> Result<(), ComponentError> {
r[0] = self.port_out.pressure().to_pascals() - self.port_in.pressure().to_pascals();
r[1] = self.port_out.enthalpy().to_joules_per_kg() - (self.port_in.enthalpy().to_joules_per_kg() + 150_000.0);
Ok(())
}
fn jacobian_entries(&self, _s: &StateSlice, _j: &mut JacobianBuilder) -> Result<(), ComponentError> { Ok(()) }
fn n_equations(&self) -> usize { 2 }
fn get_ports(&self) -> &[ConnectedPort] { &[] }
fn port_mass_flows(&self, _: &StateSlice) -> Result<Vec<MassFlow>, ComponentError> {
Ok(vec![MassFlow::from_kg_per_s(0.05), MassFlow::from_kg_per_s(-0.05)])
}
}
// ─── Helpers ──────────────────────────────────────────────────────────────────
fn port(p_pa: f64, h_j_kg: f64) -> CP {
let (connected, _) = Port::new(
FluidId::new("R134a"),
Pressure::from_pascals(p_pa),
Enthalpy::from_joules_per_kg(h_j_kg),
).connect(Port::new(
FluidId::new("R134a"),
Pressure::from_pascals(p_pa),
Enthalpy::from_joules_per_kg(h_j_kg),
)).unwrap();
connected
}
// ─── Test ─────────────────────────────────────────────────────────────────────
#[test]
fn test_simple_refrigeration_loop_rust() {
// Les équations :
// Comp : p0 = p3 + 1 MPa ; h0 = h3 + 75 kJ/kg
// Cond : p1 = p0 ; h1 = h0 - 225 kJ/kg
// Valve : p2 = p1 - 1 MPa ; h2 = h1
// Evap : p3 = p2 ; h3 = h2 + 150 kJ/kg
//
// Bilan enthalpique en boucle : 75 - 225 + 150 = 0 → fermé ✓
// Bilan pressionnel en boucle : +1 - 0 - 1 - 0 = 0 → fermé ✓
//
// Solution analytique (8 inconnues, 8 équations → infinité de solutions
// dépendant du point de référence, mais le solveur en trouve une) :
// En posant h3 = 410 kJ/kg, p3 = 350 kPa :
// h0 = 485, p0 = 1.35 MPa
// h1 = 260, p1 = 1.35 MPa
// h2 = 260, p2 = 350 kPa
// h3 = 410, p3 = 350 kPa
let p_lp = 350_000.0_f64; // Pa
let p_hp = 1_350_000.0_f64; // Pa = p_lp + 1 MPa
// Les 4 bords (edge) du cycle :
// edge0 : comp → cond
// edge1 : cond → valve
// edge2 : valve → evap
// edge3 : evap → comp
let comp = Box::new(MockCompressor {
port_suc: port(p_lp, 410_000.0),
port_disc: port(p_hp, 485_000.0),
});
let cond = Box::new(MockCondenser {
port_in: port(p_hp, 485_000.0),
port_out: port(p_hp, 260_000.0),
});
let valv = Box::new(MockValve {
port_in: port(p_hp, 260_000.0),
port_out: port(p_lp, 260_000.0),
});
let evap = Box::new(MockEvaporator {
port_in: port(p_lp, 260_000.0),
port_out: port(p_lp, 410_000.0),
});
let mut system = System::new();
let n_comp = system.add_component(comp);
let n_cond = system.add_component(cond);
let n_valv = system.add_component(valv);
let n_evap = system.add_component(evap);
system.add_edge(n_comp, n_cond).unwrap();
system.add_edge(n_cond, n_valv).unwrap();
system.add_edge(n_valv, n_evap).unwrap();
system.add_edge(n_evap, n_comp).unwrap();
system.finalize().unwrap();
let n_vars = system.full_state_vector_len();
println!("Variables d'état : {}", n_vars);
// État initial = solution analytique exacte → résidus = 0 → converge 1 itération
let initial_state = vec![
p_hp, 485_000.0, // edge0 comp→cond
p_hp, 260_000.0, // edge1 cond→valve
p_lp, 260_000.0, // edge2 valve→evap
p_lp, 410_000.0, // edge3 evap→comp
];
let mut config = NewtonConfig {
max_iterations: 50,
tolerance: 1e-6,
line_search: false,
use_numerical_jacobian: true, // analytique vide → numérique
initial_state: Some(initial_state),
..NewtonConfig::default()
};
let t0 = std::time::Instant::now();
let result = config.solve(&mut system);
let elapsed = t0.elapsed();
println!("Durée : {:?}", elapsed);
match &result {
Ok(converged) => {
println!("✅ Convergé en {} itérations ({:?})", converged.iterations, elapsed);
let sv = &converged.state;
println!(" comp→cond : P={:.2} bar, h={:.1} kJ/kg", sv[0]/1e5, sv[1]/1e3);
println!(" cond→valve : P={:.2} bar, h={:.1} kJ/kg", sv[2]/1e5, sv[3]/1e3);
println!(" valve→evap : P={:.2} bar, h={:.1} kJ/kg", sv[4]/1e5, sv[5]/1e3);
println!(" evap→comp : P={:.2} bar, h={:.1} kJ/kg", sv[6]/1e5, sv[7]/1e3);
}
Err(e) => {
panic!("❌ Solveur échoué : {:?}", e);
}
}
assert!(elapsed.as_millis() < 5000, "Doit converger en < 5 secondes");
assert!(result.is_ok(), "Solveur doit converger");
}

6
crates/solver/tests/smart_initializer.rs
View File

@@ -8,7 +8,7 @@
use approx::assert_relative_eq;
use entropyk_components::{
Component, ComponentError, JacobianBuilder, ResidualVector, SystemState,
Component, ComponentError, JacobianBuilder, ResidualVector, StateSlice,
};
use entropyk_core::{Enthalpy, Pressure, Temperature};
use entropyk_solver::{
@@ -36,7 +36,7 @@ impl LinearTargetSystem {
impl Component for LinearTargetSystem {
fn compute_residuals(
&self,
state: &SystemState,
state: &StateSlice,
residuals: &mut ResidualVector,
) -> Result<(), ComponentError> {
for (i, &t) in self.targets.iter().enumerate() {
@@ -47,7 +47,7 @@ impl Component for LinearTargetSystem {
fn jacobian_entries(
&self,
_state: &SystemState,
_state: &StateSlice,
jacobian: &mut JacobianBuilder,
) -> Result<(), ComponentError> {
for i in 0..self.targets.len() {

6
crates/solver/tests/timeout_budgeted_solving.rs
View File

@@ -8,7 +8,7 @@
//! - Timeout across fallback switches preserves best state
use entropyk_components::{
Component, ComponentError, JacobianBuilder, ResidualVector, SystemState,
Component, ComponentError, JacobianBuilder, ResidualVector, StateSlice,
};
use entropyk_solver::solver::{
ConvergenceStatus, FallbackConfig, FallbackSolver, NewtonConfig, PicardConfig, Solver,
@@ -39,7 +39,7 @@ impl LinearSystem2x2 {
impl Component for LinearSystem2x2 {
fn compute_residuals(
&self,
state: &SystemState,
state: &StateSlice,
residuals: &mut ResidualVector,
) -> Result<(), ComponentError> {
residuals[0] = self.a[0][0] * state[0] + self.a[0][1] * state[1] - self.b[0];
@@ -49,7 +49,7 @@ impl Component for LinearSystem2x2 {
fn jacobian_entries(
&self,
_state: &SystemState,
_state: &StateSlice,
jacobian: &mut JacobianBuilder,
) -> Result<(), ComponentError> {
jacobian.add_entry(0, 0, self.a[0][0]);

81
crates/solver/tests/traceability.rs Normal file
View File

@@ -0,0 +1,81 @@
use entropyk_components::port::{FluidId, Port};
use entropyk_components::{Component, ComponentError, ConnectedPort, JacobianBuilder, StateSlice};
use entropyk_core::{Enthalpy, Pressure};
use entropyk_solver::solver::{NewtonConfig, Solver};
use entropyk_solver::system::System;
struct DummyComponent {
ports: Vec<ConnectedPort>,
}
impl Component for DummyComponent {
fn compute_residuals(
&self,
_state: &StateSlice,
residuals: &mut entropyk_components::ResidualVector,
) -> Result<(), ComponentError> {
residuals[0] = 0.0;
residuals[1] = 0.0;
Ok(())
}
fn jacobian_entries(
&self,
_state: &StateSlice,
jacobian: &mut JacobianBuilder,
) -> Result<(), ComponentError> {
jacobian.add_entry(0, 0, 1.0);
jacobian.add_entry(1, 1, 1.0);
Ok(())
}
fn n_equations(&self) -> usize {
2
}
fn get_ports(&self) -> &[ConnectedPort] {
&self.ports
}
}
fn make_dummy_component() -> Box<dyn Component> {
let inlet = Port::new(
FluidId::new("R134a"),
Pressure::from_pascals(100_000.0),
Enthalpy::from_joules_per_kg(400_000.0),
);
let outlet = Port::new(
FluidId::new("R134a"),
Pressure::from_pascals(100_000.0),
Enthalpy::from_joules_per_kg(400_000.0),
);
let (connected_inlet, connected_outlet) = inlet.connect(outlet).unwrap();
let ports = vec![connected_inlet, connected_outlet];
Box::new(DummyComponent { ports })
}
#[test]
fn test_simulation_metadata_outputs() {
let mut sys = System::new();
let n0 = sys.add_component(make_dummy_component());
let n1 = sys.add_component(make_dummy_component());
sys.add_edge_with_ports(n0, 1, n1, 0).unwrap();
sys.add_edge_with_ports(n1, 1, n0, 0).unwrap();
sys.finalize().unwrap();
let input_hash = sys.input_hash();
let mut solver = NewtonConfig {
max_iterations: 5,
..Default::default()
};
let result = solver.solve(&mut sys).unwrap();
assert!(result.is_converged());
let metadata = result.metadata;
assert_eq!(metadata.input_hash, input_hash);
assert_eq!(metadata.solver_version, env!("CARGO_PKG_VERSION"));
assert_eq!(metadata.fluid_backend_version, "0.1.0");
}