get rid of most Arcs

feos-org · g-bauer · Oct 13, 2025 · Aug 18, 2025 · Aug 18, 2025 · Aug 18, 2025
commit bb8f5e52034ebed8a7c3fdf02f0798d7cd54dca0
diff --git a/crates/feos-core/src/cubic.rs b/crates/feos-core/src/cubic.rs
@@ -120,7 +120,7 @@ impl ResidualDyn for PengRobinson {
         let x = &state.molefracs;
         let ak = &self
             .tc
-            .map(|tc| (D::one() - (state.temperature / tc).sqrt()))
+            .map(|tc| D::one() - (state.temperature / tc).sqrt())
             .component_mul(&self.kappa.map(D::from))
             .map(|x| (x + 1.0).powi(2))
             .component_mul(&self.a.map(D::from));

diff --git a/crates/feos-core/src/equation_of_state/mod.rs b/crates/feos-core/src/equation_of_state/mod.rs
@@ -5,7 +5,7 @@ use nalgebra::{
     Const, DVector, DefaultAllocator, Dim, Dyn, OVector, SVector, U1, allocator::Allocator,
 };
 use num_dual::DualNum;
-use quantity::{Energy, MolarEnergy, MolarWeight, Moles, Temperature, Volume};
+use quantity::{Energy, MolarEnergy, Moles, Temperature, Volume};
 
 mod residual;
 pub use residual::{Molarweight, NoResidual, Residual, ResidualConst, ResidualDyn, Subset};
@@ -18,6 +18,13 @@ pub struct EquationOfState<I, R> {
     pub residual: R,
 }
 
+impl<I, R> Deref for EquationOfState<I, R> {
+    type Target = R;
+    fn deref(&self) -> &R {
+        &self.residual
+    }
+}
+
 impl<I, R> EquationOfState<I, R> {
     /// Return a new [EquationOfState] with the given ideal gas
     /// and residual models.
@@ -95,16 +102,6 @@ impl<I: Clone, R: ResidualConst<N, D>, D: DualNum<f64> + Copy, const N: usize> R
     }
 }
 
-impl<I, R: Molarweight<N, D>, N: Dim, D: DualNum<f64> + Copy> Molarweight<N, D>
-    for EquationOfState<I, R>
-where
-    DefaultAllocator: Allocator<N>,
-{
-    fn molar_weight(&self) -> MolarWeight<OVector<D, N>> {
-        self.residual.molar_weight()
-    }
-}
-
 /// Ideal gas Helmholtz energy contribution.
 pub trait IdealGas<D = f64> {
     /// Implementation of an ideal gas model in terms of the

diff --git a/crates/feos-core/src/state/builder.rs b/crates/feos-core/src/state/builder.rs
@@ -12,7 +12,6 @@ use quantity::*;
 /// # use feos_core::{FeosResult, StateBuilder};
 /// # use feos_core::cubic::{PengRobinson, PengRobinsonParameters};
 /// # use quantity::*;
-/// # use std::sync::Arc;
 /// # use nalgebra::dvector;
 /// # use approx::assert_relative_eq;
 /// # use typenum::P3;

diff --git a/crates/feos-core/src/state/mod.rs b/crates/feos-core/src/state/mod.rs
@@ -88,7 +88,6 @@ where
 
         Self {
             temperature,
-            // molar_volume,
             molefracs: molefracs.clone(),
             partial_density,
         }
@@ -100,7 +99,6 @@ where
 
         Self {
             temperature,
-            // molar_volume,
             molefracs,
             partial_density: partial_density.clone(),
         }
@@ -109,14 +107,9 @@ where
     // Since the molefracs can not be reproduced from moles if the density is zero,
     // this constructor exists specifically for these cases.
     pub(crate) fn new_virial(temperature: D, density: D, molefracs: &OVector<D, N>) -> Self {
-        // let volume = D::one();
         let partial_density = molefracs * density;
-        // let moles = partial_density.map(|pd| pd * volume);
-        // let molefracs = molefracs.map(D::from);
         Self {
             temperature,
-            // volume,
-            // moles,
             molefracs: molefracs.clone(),
             partial_density,
         }

diff --git a/crates/feos-dft/src/adsorption/external_potential.rs b/crates/feos-dft/src/adsorption/external_potential.rs
@@ -9,6 +9,7 @@ use ndarray::{Array1, Array2, Axis as Axis_nd};
 #[cfg(feature = "rayon")]
 use quantity::Length;
 use std::f64::consts::PI;
+use std::ops::Deref;
 
 const DELTA_STEELE: f64 = 3.35;
 
@@ -73,7 +74,7 @@ pub trait FluidParameters {
     fn sigma_ff(&self) -> DVector<f64>;
 }
 
-impl<T: FluidParameters> FluidParameters for std::sync::Arc<T> {
+impl<C: Deref<Target = T>, T: FluidParameters> FluidParameters for C {
     fn epsilon_k_ff(&self) -> DVector<f64> {
         T::epsilon_k_ff(self)
     }

diff --git a/crates/feos-dft/src/adsorption/pore.rs b/crates/feos-dft/src/adsorption/pore.rs
@@ -85,7 +85,6 @@ pub trait PoreSpecification<D: Dimension> {
 }
 
 /// Density profile and properties of a confined system in arbitrary dimensions.
-#[derive(Clone)]
 pub struct PoreProfile<D: Dimension, F> {
     pub profile: DFTProfile<D, F>,
     pub grand_potential: Option<Energy>,
@@ -165,7 +164,7 @@ where
             .profile
             .bulk
             .eos
-            .bond_integrals(temperature, &exp_pot, &convolver);
+            .bond_integrals(temperature, &exp_pot, convolver.as_ref());
         self.profile.integrate_reduced_segments(&(exp_pot * bonds))
     }
 

diff --git a/crates/feos-dft/src/convolver/mod.rs b/crates/feos-dft/src/convolver/mod.rs
@@ -7,7 +7,6 @@ use num_dual::*;
 use num_traits::Zero;
 use rustdct::DctNum;
 use std::ops::{AddAssign, MulAssign, SubAssign};
-use std::sync::Arc;
 
 mod periodic_convolver;
 mod transform;
@@ -42,12 +41,12 @@ pub(crate) struct BulkConvolver<T> {
 
 impl<T: DualNum<f64> + Copy + Send + Sync> BulkConvolver<T> {
     #[expect(clippy::new_ret_no_self)]
-    pub(crate) fn new(weight_functions: Vec<WeightFunctionInfo<T>>) -> Arc<dyn Convolver<T, Ix0>> {
+    pub(crate) fn new(weight_functions: Vec<WeightFunctionInfo<T>>) -> Box<dyn Convolver<T, Ix0>> {
         let weight_constants = weight_functions
             .into_iter()
             .map(|w| w.weight_constants(Zero::zero(), 0))
             .collect();
-        Arc::new(Self { weight_constants })
+        Box::new(Self { weight_constants })
     }
 }
 
@@ -112,7 +111,6 @@ impl<T, D: Dimension> FFTWeightFunctions<T, D> {
 /// compute convolutions in Fourier space.
 ///
 /// Parametrized over the data type `T` and the dimension `D`.
-#[derive(Clone)]
 pub struct ConvolverFFT<T, D: Dimension> {
     /// k vectors
     k_abs: Array<f64, D>,
@@ -121,9 +119,9 @@ pub struct ConvolverFFT<T, D: Dimension> {
     /// Lanczos sigma factor
     lanczos_sigma: Option<Array<f64, D>>,
     /// Possibly curvilinear Fourier transform in the first dimension
-    transform: Arc<dyn FourierTransform<T>>,
+    transform: Box<dyn FourierTransform<T>>,
     /// Vector of additional cartesian Fourier transforms in the other dimensions
-    cartesian_transforms: Vec<Arc<CartesianTransform<T>>>,
+    cartesian_transforms: Vec<CartesianTransform<T>>,
 }
 
 impl<T, D: Dimension + RemoveAxis + 'static> ConvolverFFT<T, D>
@@ -138,7 +136,7 @@ where
         grid: &Grid,
         weight_functions: &[WeightFunctionInfo<T>],
         lanczos: Option<i32>,
-    ) -> Arc<dyn Convolver<T, D>> {
+    ) -> Box<dyn Convolver<T, D>> {
         match grid {
             Grid::Polar(r) => CurvilinearConvolver::new(r, &[], weight_functions, lanczos),
             Grid::Spherical(r) => CurvilinearConvolver::new(r, &[], weight_functions, lanczos),
@@ -170,7 +168,7 @@ where
         cartesian_axes: &[&Axis],
         weight_functions: &[WeightFunctionInfo<T>],
         lanczos: Option<i32>,
-    ) -> Arc<dyn Convolver<T, D>> {
+    ) -> Box<dyn Convolver<T, D>> {
         // initialize the Fourier transform
         let mut cartesian_transforms = Vec::with_capacity(cartesian_axes.len());
         let mut k_vec = Vec::with_capacity(cartesian_axes.len() + 1);
@@ -267,7 +265,7 @@ where
         }
 
         // Return `FFTConvolver<T, D>`
-        Arc::new(Self {
+        Box::new(Self {
             k_abs,
             weight_functions: fft_weight_functions,
             lanczos_sigma,
@@ -550,8 +548,8 @@ where
 /// The curvilinear convolver accounts for the shift that has to be performed
 /// for spherical and polar transforms.
 struct CurvilinearConvolver<T, D> {
-    convolver: Arc<dyn Convolver<T, D>>,
-    convolver_boundary: Arc<dyn Convolver<T, D>>,
+    convolver: Box<dyn Convolver<T, D>>,
+    convolver_boundary: Box<dyn Convolver<T, D>>,
 }
 
 impl<T, D: Dimension + RemoveAxis + 'static> CurvilinearConvolver<T, D>
@@ -567,8 +565,8 @@ where
         z: &[&Axis],
         weight_functions: &[WeightFunctionInfo<T>],
         lanczos: Option<i32>,
-    ) -> Arc<dyn Convolver<T, D>> {
-        Arc::new(Self {
+    ) -> Box<dyn Convolver<T, D>> {
+        Box::new(Self {
             convolver: ConvolverFFT::new(Some(r), z, weight_functions, lanczos),
             convolver_boundary: ConvolverFFT::new(None, z, weight_functions, lanczos),
         })

diff --git a/crates/feos-dft/src/convolver/periodic_convolver.rs b/crates/feos-dft/src/convolver/periodic_convolver.rs
@@ -11,7 +11,6 @@ use std::f64::consts::PI;
 use std::ops::AddAssign;
 use std::sync::Arc;
 
-#[derive(Clone)]
 pub struct PeriodicConvolver<T, D: Dimension> {
     /// k vectors
     k_abs: Array<f64, D>,
@@ -36,7 +35,7 @@ where
         angle: Angle,
         weight_functions: &[WeightFunctionInfo<T>],
         lanczos: Option<i32>,
-    ) -> Arc<dyn Convolver<T, D>> {
+    ) -> Box<dyn Convolver<T, D>> {
         let f = |k: &mut Array<f64, D::Larger>| {
             let k_y =
                 (&k.index_axis(Axis(0), 1) - &k.index_axis(Axis(0), 0) * angle.cos()) / angle.sin();
@@ -50,7 +49,7 @@ where
         angles: [Angle; 3],
         weight_functions: &[WeightFunctionInfo<T>],
         lanczos: Option<i32>,
-    ) -> Arc<dyn Convolver<T, D>> {
+    ) -> Box<dyn Convolver<T, D>> {
         let f = |k: &mut Array<f64, D::Larger>| {
             let [alpha, beta, gamma] = angles;
             let [k_u, k_v, k_w] = [0, 1, 2].map(|i| k.index_axis(Axis(0), i));
@@ -73,7 +72,7 @@ where
         non_orthogonal_correction: F,
         weight_functions: &[WeightFunctionInfo<T>],
         lanczos: Option<i32>,
-    ) -> Arc<dyn Convolver<T, D>> {
+    ) -> Box<dyn Convolver<T, D>> {
         // initialize the Fourier transform
         let mut planner = FftPlanner::new();
         let mut forward_transforms = Vec::with_capacity(axes.len());
@@ -175,7 +174,7 @@ where
             });
         }
 
-        Arc::new(Self {
+        Box::new(Self {
             k_abs,
             weight_functions: fft_weight_functions,
             lanczos_sigma,

diff --git a/crates/feos-dft/src/convolver/transform.rs b/crates/feos-dft/src/convolver/transform.rs
@@ -36,14 +36,14 @@ pub(super) struct CartesianTransform<T> {
 
 impl<T: DualNum<f64> + DctNum> CartesianTransform<T> {
     #[expect(clippy::new_ret_no_self)]
-    pub(super) fn new(axis: &Axis) -> (Arc<dyn FourierTransform<T>>, Array1<f64>) {
+    pub(super) fn new(axis: &Axis) -> (Box<dyn FourierTransform<T>>, Array1<f64>) {
         let (s, k) = Self::init(axis);
-        (Arc::new(s), k)
+        (Box::new(s), k)
     }
 
-    pub(super) fn new_cartesian(axis: &Axis) -> (Arc<Self>, Array1<f64>) {
+    pub(super) fn new_cartesian(axis: &Axis) -> (Self, Array1<f64>) {
         let (s, k) = Self::init(axis);
-        (Arc::new(s), k)
+        (s, k)
     }
 
     fn init(axis: &Axis) -> (Self, Array1<f64>) {
@@ -132,12 +132,12 @@ pub(super) struct SphericalTransform<T> {
 
 impl<T: DualNum<f64> + DctNum> SphericalTransform<T> {
     #[expect(clippy::new_ret_no_self)]
-    pub(super) fn new(axis: &Axis) -> (Arc<dyn FourierTransform<T>>, Array1<f64>) {
+    pub(super) fn new(axis: &Axis) -> (Box<dyn FourierTransform<T>>, Array1<f64>) {
         let points = axis.grid.len();
         let length = axis.length();
         let k_grid: Array1<_> = (0..=points).map(|v| PI * v as f64 / length).collect();
         (
-            Arc::new(Self {
+            Box::new(Self {
                 r_grid: axis.grid.clone(),
                 k_grid: k_grid.clone(),
                 dct: DctPlanner::new().plan_dct2(points),
@@ -229,7 +229,7 @@ pub(super) struct PolarTransform<T: DctNum> {
 
 impl<T: DualNum<f64> + DctNum> PolarTransform<T> {
     #[expect(clippy::new_ret_no_self)]
-    pub(super) fn new(axis: &Axis) -> (Arc<dyn FourierTransform<T>>, Array1<f64>) {
+    pub(super) fn new(axis: &Axis) -> (Box<dyn FourierTransform<T>>, Array1<f64>) {
         let points = axis.grid.len();
 
         let mut alpha = 0.002_f64;
@@ -268,7 +268,7 @@ impl<T: DualNum<f64> + DctNum> PolarTransform<T> {
         ifft.process(jv.as_slice_mut().unwrap());
 
         (
-            Arc::new(Self {
+            Box::new(Self {
                 r_grid: axis.grid.clone(),
                 k_grid: k_grid.clone(),
                 fft,
@@ -335,8 +335,8 @@ pub(super) struct NoTransform();
 
 impl NoTransform {
     #[expect(clippy::new_ret_no_self)]
-    pub(super) fn new<T: DualNum<f64>>() -> (Arc<dyn FourierTransform<T>>, Array1<f64>) {
-        (Arc::new(Self()), arr1(&[0.0]))
+    pub(super) fn new<T: DualNum<f64>>() -> (Box<dyn FourierTransform<T>>, Array1<f64>) {
+        (Box::new(Self()), arr1(&[0.0]))
     }
 }
 

diff --git a/crates/feos-dft/src/functional.rs b/crates/feos-dft/src/functional.rs
@@ -1,8 +1,6 @@
-use crate::adsorption::FluidParameters;
 use crate::convolver::Convolver;
 use crate::functional_contribution::*;
 use crate::ideal_chain_contribution::IdealChainContribution;
-use crate::solvation::PairPotential;
 use crate::weight_functions::{WeightFunction, WeightFunctionInfo, WeightFunctionShape};
 use feos_core::{EquationOfState, FeosResult, Residual, ResidualDyn, StateHD};
 use nalgebra::{DVector, dvector};
@@ -13,7 +11,6 @@ use petgraph::graph::{Graph, UnGraph};
 use petgraph::visit::EdgeRef;
 use std::borrow::Cow;
 use std::ops::{Deref, MulAssign};
-use std::sync::Arc;
 
 impl<I: Clone, F: HelmholtzEnergyFunctionalDyn> HelmholtzEnergyFunctionalDyn
     for EquationOfState<Vec<I>, F>
@@ -36,22 +33,6 @@ impl<I: Clone, F: HelmholtzEnergyFunctionalDyn> HelmholtzEnergyFunctionalDyn
     }
 }
 
-impl<I, F: PairPotential> PairPotential for EquationOfState<I, F> {
-    fn pair_potential(&self, i: usize, r: &Array1<f64>, temperature: f64) -> Array2<f64> {
-        self.residual.pair_potential(i, r, temperature)
-    }
-}
-
-impl<I, F: FluidParameters> FluidParameters for EquationOfState<I, F> {
-    fn epsilon_k_ff(&self) -> DVector<f64> {
-        self.residual.epsilon_k_ff()
-    }
-
-    fn sigma_ff(&self) -> DVector<f64> {
-        self.residual.sigma_ff()
-    }
-}
-
 /// Different representations for molecules within DFT.
 pub enum MoleculeShape<'a> {
     /// For spherical molecules, the number of components.
@@ -135,7 +116,7 @@ pub trait HelmholtzEnergyFunctional: Residual {
         &self,
         temperature: N,
         density: &Array<N, D::Larger>,
-        convolver: &Arc<dyn Convolver<N, D>>,
+        convolver: &dyn Convolver<N, D>,
     ) -> FeosResult<(Array<N, D>, Array<N, D::Larger>)>
     where
         D: Dimension,
@@ -170,7 +151,7 @@ pub trait HelmholtzEnergyFunctional: Residual {
         &self,
         temperature: N,
         exponential: &Array<N, D::Larger>,
-        convolver: &Arc<dyn Convolver<N, D>>,
+        convolver: &dyn Convolver<N, D>,
     ) -> Array<N, D::Larger>
     where
         D: Dimension,