moved subset to new Components trait, eliminated DeBroglieWavelength …

…trait
feos-org · prehner · Jul 7, 2023 · Jun 1, 2023 · Jun 1, 2023 · Jun 1, 2023
commit 48e98bafc059be447fe844ef47100dbf9faf5ac4
diff --git a/feos-core/src/cubic.rs b/feos-core/src/cubic.rs
@@ -4,7 +4,7 @@
 //! of state - with a single contribution to the Helmholtz energy - can be implemented.
 //! The implementation closely follows the form of the equations given in
 //! [this wikipedia article](https://en.wikipedia.org/wiki/Cubic_equations_of_state#Peng%E2%80%93Robinson_equation_of_state).
-use crate::equation_of_state::{HelmholtzEnergy, HelmholtzEnergyDual, Residual};
+use crate::equation_of_state::{Components, HelmholtzEnergy, HelmholtzEnergyDual, Residual};
 use crate::parameter::{Identifier, Parameter, ParameterError, PureRecord};
 use crate::si::{GRAM, MOL};
 use crate::state::StateHD;
@@ -144,12 +144,7 @@ impl Parameter for PengRobinsonParameters {
         }
     }
 
-    fn records(
-        &self,
-    ) -> (
-        &[PureRecord<PengRobinsonRecord>],
-        &Array2<f64>,
-    ) {
+    fn records(&self) -> (&[PureRecord<PengRobinsonRecord>], &Array2<f64>) {
         (&self.pure_records, &self.k_ij)
     }
 }
@@ -219,15 +214,17 @@ impl fmt::Display for PengRobinson {
     }
 }
 
-impl Residual for PengRobinson {
+impl Components for PengRobinson {
     fn components(&self) -> usize {
         self.parameters.b.len()
     }
 
     fn subset(&self, component_list: &[usize]) -> Self {
         Self::new(Arc::new(self.parameters.subset(component_list)))
     }
+}
 
+impl Residual for PengRobinson {
     fn compute_max_density(&self, moles: &Array1<f64>) -> f64 {
         let b = (moles * &self.parameters.b).sum() / moles.sum();
         0.9 / b

diff --git a/feos-core/src/equation_of_state/__ideal_gas.rs b/feos-core/src/equation_of_state/__ideal_gas.rs
diff --git a/feos-core/src/equation_of_state/debroglie.rs b/feos-core/src/equation_of_state/debroglie.rs
diff --git a/feos-core/src/equation_of_state/ideal_gas.rs b/feos-core/src/equation_of_state/ideal_gas.rs
@@ -1,8 +1,7 @@
+use super::Components;
 use crate::StateHD;
+use ndarray::Array1;
 use num_dual::DualNum;
-use std::fmt;
-
-use super::debroglie::{DeBroglieWavelength, DeBroglieWavelengthDual};
 
 /// Ideal gas Helmholtz energy contribution that can
 /// be evaluated using generalized (hyper) dual numbers.
@@ -11,28 +10,18 @@ use super::debroglie::{DeBroglieWavelength, DeBroglieWavelengthDual};
 /// the specific types in the supertraits of [IdealGasContribution]
 /// so that the implementor can be used as an ideal gas
 /// contribution in the equation of state.
-pub trait IdealGas: Sync + Send + fmt::Display {
-    // /// Return the number of components
-    // fn components(&self) -> usize;
-
-    /// Return an equation of state consisting of the components
-    /// contained in component_list.
-    fn subset(&self, component_list: &[usize]) -> Self;
+pub trait IdealGas: Components + Sync + Send {
+    fn de_broglie_wavelength<D: DualNum<f64> + Copy>(&self, temperature: D) -> Array1<D>;
 
-    fn ideal_gas_model(&self) -> &Box<dyn DeBroglieWavelength>;
+    fn ideal_gas_model(&self) -> String;
 
     /// Evaluate the ideal gas contribution for a given state.
     ///
     /// In some cases it could be advantageous to overwrite this
     /// implementation instead of implementing the de Broglie
     /// wavelength.
-    fn evaluate_ideal_gas<D: DualNum<f64> + Copy>(&self, state: &StateHD<D>) -> D
-    where
-        dyn DeBroglieWavelength: DeBroglieWavelengthDual<D>,
-    {
-        let lambda = self
-            .ideal_gas_model()
-            .de_broglie_wavelength(state.temperature);
+    fn evaluate_ideal_gas<D: DualNum<f64> + Copy>(&self, state: &StateHD<D>) -> D {
+        let lambda = self.de_broglie_wavelength(state.temperature);
         ((lambda
             + state.partial_density.mapv(|x| {
                 if x.re() == 0.0 {

diff --git a/feos-core/src/equation_of_state/mod.rs b/feos-core/src/equation_of_state/mod.rs
@@ -1,15 +1,13 @@
 use ndarray::Array1;
 use num_dual::DualNum;
 use quantity::si::{SIArray1, SINumber};
-use std::{fmt::Display, sync::Arc};
+use std::sync::Arc;
 
-pub mod debroglie;
 pub mod helmholtz_energy;
 pub mod ideal_gas;
 pub mod residual;
-use crate::{EosResult, StateHD};
+use crate::EosResult;
 
-pub use self::debroglie::{DeBroglieWavelength, DeBroglieWavelengthDual};
 pub use helmholtz_energy::{HelmholtzEnergy, HelmholtzEnergyDual};
 pub use ideal_gas::IdealGas;
 pub use residual::{EntropyScaling, Residual};
@@ -22,42 +20,34 @@ pub trait MolarWeight {
     fn molar_weight(&self) -> SIArray1;
 }
 
+pub trait Components {
+    /// Return the number of components of the model.
+    fn components(&self) -> usize;
+
+    /// Return a model consisting of the components
+    /// contained in component_list.
+    fn subset(&self, component_list: &[usize]) -> Self;
+}
+
 #[derive(Clone)]
 pub struct EquationOfState<I, R> {
     pub ideal_gas: Arc<I>,
     pub residual: Arc<R>,
-    components: usize,
-}
-
-impl<I: IdealGas, R: Residual> Display for EquationOfState<I, R> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "{} {}",
-            self.ideal_gas.to_string(),
-            self.residual.to_string()
-        )
-    }
 }
 
-impl<I: IdealGas, R: Residual> EquationOfState<I, R> {
+impl<I, R> EquationOfState<I, R> {
     pub fn new(ideal_gas: Arc<I>, residual: Arc<R>) -> Self {
-        // assert_eq!(residual.components(), ideal_gas.components());
-        let components = residual.components();
         Self {
             ideal_gas,
             residual,
-            components,
         }
     }
 }
 
-impl<I: IdealGas, R: Residual> IdealGas for EquationOfState<I, R> {
-    fn evaluate_ideal_gas<D: DualNum<f64> + Copy>(&self, state: &StateHD<D>) -> D
-    where
-        dyn DeBroglieWavelength: DeBroglieWavelengthDual<D>,
-    {
-        self.ideal_gas.evaluate_ideal_gas(state)
+impl<I: Components, R: Components> Components for EquationOfState<I, R> {
+    fn components(&self) -> usize {
+        assert_eq!(self.residual.components(), self.ideal_gas.components());
+        self.residual.components()
     }
 
     fn subset(&self, component_list: &[usize]) -> Self {
@@ -66,24 +56,19 @@ impl<I: IdealGas, R: Residual> IdealGas for EquationOfState<I, R> {
             Arc::new(self.residual.subset(component_list)),
         )
     }
-
-    fn ideal_gas_model(&self) -> &Box<dyn DeBroglieWavelength> {
-        self.ideal_gas.ideal_gas_model()
-    }
 }
 
-impl<I: IdealGas, R: Residual> Residual for EquationOfState<I, R> {
-    fn components(&self) -> usize {
-        self.residual.components()
+impl<I: IdealGas, R: Residual> IdealGas for EquationOfState<I, R> {
+    fn de_broglie_wavelength<D: DualNum<f64> + Copy>(&self, temperature: D) -> Array1<D> {
+        self.ideal_gas.de_broglie_wavelength(temperature)
     }
 
-    fn subset(&self, component_list: &[usize]) -> Self {
-        Self::new(
-            Arc::new(self.ideal_gas.subset(component_list)),
-            Arc::new(self.residual.subset(component_list)),
-        )
+    fn ideal_gas_model(&self) -> String {
+        self.ideal_gas.ideal_gas_model()
     }
+}
 
+impl<I: IdealGas, R: Residual> Residual for EquationOfState<I, R> {
     fn compute_max_density(&self, moles: &Array1<f64>) -> f64 {
         self.residual.compute_max_density(moles)
     }

diff --git a/feos-core/src/equation_of_state/residual.rs b/feos-core/src/equation_of_state/residual.rs
@@ -1,21 +1,13 @@
-use super::{HelmholtzEnergy, HelmholtzEnergyDual};
+use super::{Components, HelmholtzEnergy, HelmholtzEnergyDual};
 use crate::StateHD;
 use crate::{EosError, EosResult, EosUnit};
 use ndarray::prelude::*;
 use num_dual::*;
 use num_traits::{One, Zero};
 use quantity::si::{SIArray1, SINumber, SIUnit};
-use std::fmt;
 
 /// A general equation of state.
-pub trait Residual: Send + Sync + fmt::Display {
-    /// Return the number of components of the equation of state.
-    fn components(&self) -> usize;
-
-    /// Return an equation of state consisting of the components
-    /// contained in component_list.
-    fn subset(&self, component_list: &[usize]) -> Self;
-
+pub trait Residual: Components + Send + Sync {
     /// Return the maximum density in Angstrom^-3.
     ///
     /// This value is used as an estimate for a liquid phase for phase
@@ -177,4 +169,4 @@ pub trait EntropyScaling {
         moles: &SIArray1,
     ) -> EosResult<SINumber>;
     fn thermal_conductivity_correlation(&self, s_res: f64, x: &Array1<f64>) -> EosResult<f64>;
-}
+}