remove the ResidualConst trait

feos-org · g-bauer · Oct 13, 2025 · Aug 18, 2025 · Aug 18, 2025 · Aug 18, 2025
commit 935b651e9c9f03488212865718508aa1ffefd285
diff --git a/crates/feos-core/src/equation_of_state/mod.rs b/crates/feos-core/src/equation_of_state/mod.rs
@@ -8,7 +8,7 @@ use num_dual::DualNum;
 use quantity::{Energy, MolarEnergy, Moles, Temperature, Volume};
 
 mod residual;
-pub use residual::{Molarweight, NoResidual, Residual, ResidualConst, ResidualDyn, Subset};
+pub use residual::{Molarweight, NoResidual, Residual, ResidualDyn, Subset};
 
 /// An equation of state consisting of an ideal gas model
 /// and a residual Helmholtz energy model.
@@ -79,10 +79,13 @@ impl<I: Clone, R: Subset> Subset for EquationOfState<Vec<I>, R> {
     }
 }
 
-impl<I: Clone, R: ResidualConst<N, D>, D: DualNum<f64> + Copy, const N: usize> ResidualConst<N, D>
-    for EquationOfState<[I; N], R>
+impl<I: Clone, R: Residual<Const<N>, D>, D: DualNum<f64> + Copy, const N: usize>
+    Residual<Const<N>, D> for EquationOfState<[I; N], R>
 {
-    const NAME: &str = R::NAME;
+    fn components(&self) -> usize {
+        N
+    }
+
     type Real = EquationOfState<[I; N], R::Real>;
     type Lifted<D2: DualNum<f64, Inner = D> + Copy> = EquationOfState<[I; N], R::Lifted<D2>>;
     fn re(&self) -> Self::Real {
@@ -96,6 +99,14 @@ impl<I: Clone, R: ResidualConst<N, D>, D: DualNum<f64> + Copy, const N: usize> R
         self.residual.compute_max_density(molefracs)
     }
 
+    fn reduced_helmholtz_energy_density_contributions(
+        &self,
+        state: &StateHD<D, Const<N>>,
+    ) -> Vec<(&'static str, D)> {
+        self.residual
+            .reduced_helmholtz_energy_density_contributions(state)
+    }
+
     fn reduced_residual_helmholtz_energy_density(&self, state: &StateHD<D, Const<N>>) -> D {
         self.residual
             .reduced_residual_helmholtz_energy_density(state)
@@ -184,12 +195,8 @@ impl<
     }
 }
 
-impl<
-    I: IdealGas<D> + Clone,
-    R: ResidualConst<N, D> + 'static,
-    D: DualNum<f64> + Copy,
-    const N: usize,
-> Total<Const<N>, D> for EquationOfState<[I; N], R>
+impl<I: IdealGas<D> + Clone, R: Residual<Const<N>, D>, D: DualNum<f64> + Copy, const N: usize>
+    Total<Const<N>, D> for EquationOfState<[I; N], R>
 {
     type IdealGas = I;
 

diff --git a/crates/feos-core/src/equation_of_state/residual.rs b/crates/feos-core/src/equation_of_state/residual.rs
@@ -1,7 +1,5 @@
 use crate::{FeosError, FeosResult, ReferenceSystem, state::StateHD};
-use nalgebra::{
-    Const, DVector, DefaultAllocator, Dim, Dyn, OMatrix, OVector, SVector, U1, allocator::Allocator,
-};
+use nalgebra::{DVector, DefaultAllocator, Dim, Dyn, OMatrix, OVector, U1, allocator::Allocator};
 use num_dual::{DualNum, Gradients, partial, partial2, second_derivative, third_derivative};
 use quantity::ad::first_derivative;
 use quantity::*;
@@ -83,52 +81,6 @@ impl<C: Deref<Target = T> + Clone, T: ResidualDyn, D: DualNum<f64> + Copy> Resid
     }
 }
 
-pub trait ResidualConst<const N: usize, D: DualNum<f64> + Copy>: Clone {
-    const NAME: &str;
-    type Real: ResidualConst<N, f64>;
-    type Lifted<D2: DualNum<f64, Inner = D> + Copy>: ResidualConst<N, D2>;
-    fn re(&self) -> Self::Real;
-    fn lift<D2: DualNum<f64, Inner = D> + Copy>(&self) -> Self::Lifted<D2>;
-    fn compute_max_density(&self, molefracs: &SVector<D, N>) -> D;
-    fn reduced_residual_helmholtz_energy_density(&self, state: &StateHD<D, Const<N>>) -> D;
-}
-
-impl<T: ResidualConst<N, D>, const N: usize, D: DualNum<f64> + Copy> Residual<Const<N>, D> for T {
-    fn components(&self) -> usize {
-        N
-    }
-
-    type Real = T::Real;
-
-    type Lifted<D2: DualNum<f64, Inner = D> + Copy> = T::Lifted<D2>;
-
-    fn re(&self) -> Self::Real {
-        T::re(self)
-    }
-
-    fn lift<D2: DualNum<f64, Inner = D> + Copy>(&self) -> Self::Lifted<D2> {
-        T::lift(self)
-    }
-
-    fn compute_max_density(&self, molefracs: &SVector<D, N>) -> D {
-        T::compute_max_density(self, molefracs)
-    }
-
-    fn reduced_helmholtz_energy_density_contributions(
-        &self,
-        state: &StateHD<D, Const<N>>,
-    ) -> Vec<(&'static str, D)> {
-        vec![(
-            T::NAME,
-            T::reduced_residual_helmholtz_energy_density(self, state),
-        )]
-    }
-
-    fn reduced_residual_helmholtz_energy_density(&self, state: &StateHD<D, Const<N>>) -> D {
-        T::reduced_residual_helmholtz_energy_density(self, state)
-    }
-}
-
 /// A residual Helmholtz energy model.
 pub trait Residual<N: Dim = Dyn, D: DualNum<f64> + Copy = f64>: Clone
 where

diff --git a/crates/feos-core/src/lib.rs b/crates/feos-core/src/lib.rs
@@ -34,8 +34,7 @@ mod parameter_fit;
 mod phase_equilibria;
 mod state;
 pub use equation_of_state::{
-    EquationOfState, IdealGas, Molarweight, NoResidual, Residual, ResidualConst, ResidualDyn,
-    Subset, Total,
+    EquationOfState, IdealGas, Molarweight, NoResidual, Residual, ResidualDyn, Subset, Total,
 };
 pub use errors::{FeosError, FeosResult};
 pub use parameter_fit::{BinaryModel, ParametersAD, PureModel};

diff --git a/crates/feos/src/gc_pcsaft/eos/ad.rs b/crates/feos/src/gc_pcsaft/eos/ad.rs
@@ -1,6 +1,6 @@
 use super::dispersion::{A0, A1, A2, B0, B1, B2};
 use super::polar::{AD, BD, CD};
-use feos_core::{ResidualConst, StateHD};
+use feos_core::{Residual, StateHD};
 use nalgebra::{Const, SMatrix, SVector};
 use num_dual::DualNum;
 use quantity::{JOULE, KB, KELVIN};
@@ -220,8 +220,10 @@ impl<D: DualNum<f64> + Copy, const N: usize> GcPcSaftADParameters<D, N> {
 #[derive(Clone)]
 pub struct GcPcSaftAD<D, const N: usize>(pub GcPcSaftADParameters<D, N>);
 
-impl<D: DualNum<f64> + Copy, const N: usize> ResidualConst<N, D> for GcPcSaftAD<D, N> {
-    const NAME: &str = "gc-PC-SAFT";
+impl<D: DualNum<f64> + Copy, const N: usize> Residual<Const<N>, D> for GcPcSaftAD<D, N> {
+    fn components(&self) -> usize {
+        N
+    }
 
     type Real = GcPcSaftAD<f64, N>;
     type Lifted<D2: DualNum<f64, Inner = D> + Copy> = GcPcSaftAD<D2, N>;
@@ -246,6 +248,16 @@ impl<D: DualNum<f64> + Copy, const N: usize> ResidualConst<N, D> for GcPcSaftAD<
         ((msigma3 * molefracs).into_scalar() * FRAC_PI_6).recip() * MAX_ETA
     }
 
+    fn reduced_helmholtz_energy_density_contributions(
+        &self,
+        state: &StateHD<D, Const<N>>,
+    ) -> Vec<(&'static str, D)> {
+        vec![(
+            "gc-PC-SAFT",
+            self.reduced_residual_helmholtz_energy_density(state),
+        )]
+    }
+
     fn reduced_residual_helmholtz_energy_density(&self, state: &StateHD<D, Const<N>>) -> D {
         let GcPcSaftADParameters { groups, bonds } = &self.0;
         let density = &state.partial_density;

diff --git a/crates/feos/src/ideal_gas/joback.rs b/crates/feos/src/ideal_gas/joback.rs
@@ -320,7 +320,7 @@ pub mod test_ad {
     use super::{Joback, JobackParameters, JobackRecord};
     use approx::assert_relative_eq;
     use feos_core::{Contributions::IdealGas, EquationOfState, FeosResult, State};
-    use feos_core::{ResidualConst, StateHD};
+    use feos_core::{Residual, StateHD};
     use nalgebra::{SVector, U1};
     use num_dual::DualNum;
     use quantity::{KELVIN, KILO, METER, MOL};
@@ -342,8 +342,10 @@ pub mod test_ad {
     #[derive(Clone, Copy)]
     struct NoResidual;
 
-    impl<D: DualNum<f64> + Copy> ResidualConst<1, D> for NoResidual {
-        const NAME: &str = "";
+    impl<D: DualNum<f64> + Copy> Residual<U1, D> for NoResidual {
+        fn components(&self) -> usize {
+            1
+        }
 
         type Real = Self;
 
@@ -361,6 +363,13 @@ pub mod test_ad {
             D::from(1.0)
         }
 
+        fn reduced_helmholtz_energy_density_contributions(
+            &self,
+            _: &StateHD<D, U1>,
+        ) -> Vec<(&'static str, D)> {
+            vec![]
+        }
+
         fn reduced_residual_helmholtz_energy_density(&self, _: &StateHD<D, U1>) -> D {
             D::from(0.0)
         }

diff --git a/crates/feos/src/pcsaft/eos/pcsaft_binary.rs b/crates/feos/src/pcsaft/eos/pcsaft_binary.rs
@@ -1,6 +1,6 @@
 use super::dispersion::{A0, A1, A2, B0, B1, B2};
 use super::polar::{AD, BD, CD};
-use feos_core::{ParametersAD, ResidualConst, StateHD};
+use feos_core::{ParametersAD, Residual, StateHD};
 use nalgebra::{SVector, U2};
 use num_dual::{DualNum, DualSVec, DualSVec64, DualVec, jacobian};
 use std::f64::consts::{FRAC_PI_6, PI};
@@ -361,8 +361,11 @@ fn helmholtz_energy_density<D: DualNum<f64> + Copy>(
     }
 }
 
-impl<D: DualNum<f64> + Copy> ResidualConst<2, D> for PcSaftBinary<D, 4> {
-    const NAME: &str = "PC-SAFT (binary, non-assoc)";
+impl<D: DualNum<f64> + Copy> Residual<U2, D> for PcSaftBinary<D, 4> {
+    fn components(&self) -> usize {
+        2
+    }
+
     type Real = PcSaftBinary<f64, 4>;
     type Lifted<D2: DualNum<f64, Inner = D> + Copy> = PcSaftBinary<D2, 4>;
     fn re(&self) -> Self::Real {
@@ -389,6 +392,16 @@ impl<D: DualNum<f64> + Copy> ResidualConst<2, D> for PcSaftBinary<D, 4> {
         ((m1 * sigma1.powi(3) * x1 + m2 * sigma2.powi(3) * x2) * FRAC_PI_6).recip() * MAX_ETA
     }
 
+    fn reduced_helmholtz_energy_density_contributions(
+        &self,
+        state: &StateHD<D, U2>,
+    ) -> Vec<(&'static str, D)> {
+        vec![(
+            "PC-SAFT (binary, non-assoc)",
+            self.reduced_residual_helmholtz_energy_density(state),
+        )]
+    }
+
     fn reduced_residual_helmholtz_energy_density(&self, state: &StateHD<D, U2>) -> D {
         let ([p1, p2], kij) = self.0;
         let [m1, sigma1, epsilon_k1, mu1] = p1;
@@ -405,8 +418,11 @@ impl<D: DualNum<f64> + Copy> ResidualConst<2, D> for PcSaftBinary<D, 4> {
     }
 }
 
-impl<D: DualNum<f64> + Copy> ResidualConst<2, D> for PcSaftBinary<D, 8> {
-    const NAME: &str = "PC-SAFT (binary)";
+impl<D: DualNum<f64> + Copy> Residual<U2, D> for PcSaftBinary<D, 8> {
+    fn components(&self) -> usize {
+        2
+    }
+
     type Real = PcSaftBinary<f64, 8>;
     type Lifted<D2: DualNum<f64, Inner = D> + Copy> = PcSaftBinary<D2, 8>;
     fn re(&self) -> Self::Real {
@@ -433,6 +449,16 @@ impl<D: DualNum<f64> + Copy> ResidualConst<2, D> for PcSaftBinary<D, 8> {
         ((m1 * sigma1.powi(3) * x1 + m2 * sigma2.powi(3) * x2) * FRAC_PI_6).recip() * MAX_ETA
     }
 
+    fn reduced_helmholtz_energy_density_contributions(
+        &self,
+        state: &StateHD<D, U2>,
+    ) -> Vec<(&'static str, D)> {
+        vec![(
+            "PC-SAFT (binary)",
+            self.reduced_residual_helmholtz_energy_density(state),
+        )]
+    }
+
     fn reduced_residual_helmholtz_energy_density(&self, state: &StateHD<D, U2>) -> D {
         let ([p1, p2], kij) = self.0;
         let [

diff --git a/crates/feos/src/pcsaft/eos/pcsaft_pure.rs b/crates/feos/src/pcsaft/eos/pcsaft_pure.rs
@@ -1,6 +1,6 @@
 use super::dispersion::{A0, A1, A2, B0, B1, B2};
 use super::polar::{AD, BD, CD};
-use feos_core::{ParametersAD, ResidualConst, StateHD};
+use feos_core::{ParametersAD, Residual, StateHD};
 use nalgebra::{SVector, U1};
 use num_dual::{DualNum, DualSVec64};
 use std::f64::consts::{FRAC_PI_6, PI};
@@ -112,8 +112,11 @@ fn helmholtz_energy_density<D: DualNum<f64> + Copy>(
     non_assoc + assoc
 }
 
-impl<D: DualNum<f64> + Copy> ResidualConst<1, D> for PcSaftPure<D, 8> {
-    const NAME: &str = "PC-SAFT (pure)";
+impl<D: DualNum<f64> + Copy> Residual<U1, D> for PcSaftPure<D, 8> {
+    fn components(&self) -> usize {
+        1
+    }
+
     type Real = PcSaftPure<f64, 8>;
     type Lifted<D2: DualNum<f64, Inner = D> + Copy> = PcSaftPure<D2, 8>;
     fn re(&self) -> Self::Real {
@@ -128,14 +131,27 @@ impl<D: DualNum<f64> + Copy> ResidualConst<1, D> for PcSaftPure<D, 8> {
         (m * sigma.powi(3) * FRAC_PI_6).recip() * MAX_ETA
     }
 
+    fn reduced_helmholtz_energy_density_contributions(
+        &self,
+        state: &StateHD<D, U1>,
+    ) -> Vec<(&'static str, D)> {
+        vec![(
+            "PC-SAFT (pure)",
+            self.reduced_residual_helmholtz_energy_density(state),
+        )]
+    }
+
     fn reduced_residual_helmholtz_energy_density(&self, state: &StateHD<D, U1>) -> D {
         let density = state.partial_density.data.0[0][0];
         helmholtz_energy_density(&self.0, state.temperature, density)
     }
 }
 
-impl<D: DualNum<f64> + Copy> ResidualConst<1, D> for PcSaftPure<D, 4> {
-    const NAME: &str = "PC-SAFT (pure, non-assoc)";
+impl<D: DualNum<f64> + Copy> Residual<U1, D> for PcSaftPure<D, 4> {
+    fn components(&self) -> usize {
+        1
+    }
+
     type Real = PcSaftPure<f64, 4>;
     type Lifted<D2: DualNum<f64, Inner = D> + Copy> = PcSaftPure<D2, 4>;
     fn re(&self) -> Self::Real {
@@ -150,6 +166,16 @@ impl<D: DualNum<f64> + Copy> ResidualConst<1, D> for PcSaftPure<D, 4> {
         (m * sigma.powi(3) * FRAC_PI_6).recip() * MAX_ETA
     }
 
+    fn reduced_helmholtz_energy_density_contributions(
+        &self,
+        state: &StateHD<D, U1>,
+    ) -> Vec<(&'static str, D)> {
+        vec![(
+            "PC-SAFT (pure, non-assoc)",
+            self.reduced_residual_helmholtz_energy_density(state),
+        )]
+    }
+
     fn reduced_residual_helmholtz_energy_density(&self, state: &StateHD<D, U1>) -> D {
         let density = state.partial_density.data.0[0][0];
         let [m, sigma, epsilon_k, mu] = self.0;