diff --git a/src/cubic.rs b/src/cubic.rs
index 92651b9..8062487 100644
--- a/src/cubic.rs
+++ b/src/cubic.rs
@@ -254,7 +254,7 @@ impl MolarWeight<SIUnit> for PengRobinson {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::phase_equilibria::VLEOptions;
+    use crate::phase_equilibria::SolverOptions;
     use crate::state::State;
     use crate::Contributions;
     use crate::{EosResult, Verbosity};
@@ -309,7 +309,7 @@ mod tests {
         let parameters =
             PengRobinsonParameters::from_records(vec![propane.clone()], Array2::zeros((1, 1)));
         let pr = Rc::new(PengRobinson::new(Rc::new(parameters)));
-        let options = VLEOptions::new().verbosity(Verbosity::Iter);
+        let options = SolverOptions::new().verbosity(Verbosity::Iter);
         let cp = State::critical_point(&pr, None, None, options)?;
         println!("{} {}", cp.temperature, cp.pressure(Contributions::Total));
         assert_relative_eq!(cp.temperature, tc * KELVIN, max_relative = 1e-4);
diff --git a/src/lib.rs b/src/lib.rs
index 8a6a62d..a62d053 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -37,7 +37,7 @@ pub use equation_of_state::{
 };
 pub use errors::{EosError, EosResult};
 pub use phase_equilibria::{
-    PhaseDiagramBinary, PhaseDiagramHetero, PhaseDiagramPure, PhaseEquilibrium, VLEOptions,
+    PhaseDiagramBinary, PhaseDiagramHetero, PhaseDiagramPure, PhaseEquilibrium, SolverOptions,
     Verbosity,
 };
 pub use state::{Contributions, DensityInitialization, State, StateBuilder, StateHD};
diff --git a/src/phase_equilibria/bubble_dew.rs b/src/phase_equilibria/bubble_dew.rs
index ebabc2e..645a474 100644
--- a/src/phase_equilibria/bubble_dew.rs
+++ b/src/phase_equilibria/bubble_dew.rs
@@ -1,4 +1,4 @@
-use super::{PhaseEquilibrium, VLEOptions, Verbosity};
+use super::{PhaseEquilibrium, SolverOptions, Verbosity};
 use crate::errors::{EosError, EosResult};
 use crate::state::{
     Contributions,
@@ -75,7 +75,7 @@ impl<U: EosUnit, E: EquationOfState> PhaseEquilibrium<U, E, 2> {
         pressure: Option<QuantityScalar<U>>,
         liquid_molefracs: &Array1<f64>,
         vapor_molefracs: Option<&Array1<f64>>,
-        options: (VLEOptions, VLEOptions),
+        options: (SolverOptions, SolverOptions),
     ) -> EosResult<Self>
     where
         QuantityScalar<U>: std::fmt::Display,
@@ -99,7 +99,7 @@ impl<U: EosUnit, E: EquationOfState> PhaseEquilibrium<U, E, 2> {
         temperature: Option<QuantityScalar<U>>,
         liquid_molefracs: &Array1<f64>,
         vapor_molefracs: Option<&Array1<f64>>,
-        options: (VLEOptions, VLEOptions),
+        options: (SolverOptions, SolverOptions),
     ) -> EosResult<Self>
     where
         QuantityScalar<U>: std::fmt::Display,
@@ -123,7 +123,7 @@ impl<U: EosUnit, E: EquationOfState> PhaseEquilibrium<U, E, 2> {
         pressure: Option<QuantityScalar<U>>,
         vapor_molefracs: &Array1<f64>,
         liquid_molefracs: Option<&Array1<f64>>,
-        options: (VLEOptions, VLEOptions),
+        options: (SolverOptions, SolverOptions),
     ) -> EosResult<Self>
     where
         QuantityScalar<U>: std::fmt::Display,
@@ -147,7 +147,7 @@ impl<U: EosUnit, E: EquationOfState> PhaseEquilibrium<U, E, 2> {
         temperature: Option<QuantityScalar<U>>,
         vapor_molefracs: &Array1<f64>,
         liquid_molefracs: Option<&Array1<f64>>,
-        options: (VLEOptions, VLEOptions),
+        options: (SolverOptions, SolverOptions),
     ) -> EosResult<Self>
     where
         QuantityScalar<U>: std::fmt::Display,
@@ -170,7 +170,7 @@ impl<U: EosUnit, E: EquationOfState> PhaseEquilibrium<U, E, 2> {
         molefracs_spec: &Array1<f64>,
         molefracs_init: Option<&Array1<f64>>,
         bubble: bool,
-        options: (VLEOptions, VLEOptions),
+        options: (SolverOptions, SolverOptions),
     ) -> EosResult<Self>
     where
         QuantityScalar<U>: std::fmt::Display,
@@ -259,7 +259,7 @@ fn bubble_dew<U: EosUnit, E: EquationOfState>(
     mut var_tp: TPSpec<U>,
     mut state1: State<U, E>,
     mut state2: State<U, E>,
-    options: (VLEOptions, VLEOptions),
+    options: (SolverOptions, SolverOptions),
 ) -> EosResult<PhaseEquilibrium<U, E, 2>>
 where
     QuantityScalar<U>: std::fmt::Display,
diff --git a/src/phase_equilibria/mod.rs b/src/phase_equilibria/mod.rs
index e980fd9..27ae334 100644
--- a/src/phase_equilibria/mod.rs
+++ b/src/phase_equilibria/mod.rs
@@ -38,7 +38,7 @@ impl Default for Verbosity {
 /// If the values are [None], solver specific default
 ///  values are used.
 #[derive(Copy, Clone, Default)]
-pub struct VLEOptions {
+pub struct SolverOptions {
     /// Maximum number of iterations.
     pub max_iter: Option<usize>,
     /// Tolerance.
@@ -47,7 +47,7 @@ pub struct VLEOptions {
     pub verbosity: Verbosity,
 }
 
-impl From<(Option<usize>, Option<f64>, Option<Verbosity>)> for VLEOptions {
+impl From<(Option<usize>, Option<f64>, Option<Verbosity>)> for SolverOptions {
     fn from(options: (Option<usize>, Option<f64>, Option<Verbosity>)) -> Self {
         Self {
             max_iter: options.0,
@@ -57,7 +57,7 @@ impl From<(Option<usize>, Option<f64>, Option<Verbosity>)> for VLEOptions {
     }
 }
 
-impl VLEOptions {
+impl SolverOptions {
     pub fn new() -> Self {
         Self::default()
     }
diff --git a/src/phase_equilibria/phase_diagram_binary.rs b/src/phase_equilibria/phase_diagram_binary.rs
index 5c284b3..c779093 100644
--- a/src/phase_equilibria/phase_diagram_binary.rs
+++ b/src/phase_equilibria/phase_diagram_binary.rs
@@ -1,4 +1,4 @@
-use super::{PhaseEquilibrium, VLEOptions};
+use super::{PhaseEquilibrium, SolverOptions};
 use crate::equation_of_state::EquationOfState;
 use crate::errors::{EosError, EosResult};
 use num_dual::linalg::{norm, LU};
@@ -34,7 +34,7 @@ impl<U: EosUnit, E: EquationOfState> PhaseDiagramBinary<U, E> {
         pressure: QuantityScalar<U>,
         npoints: Option<usize>,
         x_lle: Option<(f64, f64)>,
-        bubble_dew_options: (VLEOptions, VLEOptions),
+        bubble_dew_options: (SolverOptions, SolverOptions),
     ) -> EosResult<Self>
     where
         QuantityScalar<U>: std::fmt::Display + std::fmt::LowerExp,
@@ -58,7 +58,7 @@ impl<U: EosUnit, E: EquationOfState> PhaseDiagramBinary<U, E> {
         temperature: QuantityScalar<U>,
         npoints: Option<usize>,
         x_lle: Option<(f64, f64)>,
-        bubble_dew_options: (VLEOptions, VLEOptions),
+        bubble_dew_options: (SolverOptions, SolverOptions),
     ) -> EosResult<Self>
     where
         QuantityScalar<U>: std::fmt::Display + std::fmt::LowerExp,
@@ -77,7 +77,7 @@ impl<U: EosUnit, E: EquationOfState> PhaseDiagramBinary<U, E> {
         tp: TPSpec<U>,
         npoints: Option<usize>,
         x_lle: Option<(f64, f64)>,
-        bubble_dew_options: (VLEOptions, VLEOptions),
+        bubble_dew_options: (SolverOptions, SolverOptions),
     ) -> EosResult<Self>
     where
         QuantityScalar<U>: std::fmt::Display + std::fmt::LowerExp,
@@ -110,12 +110,12 @@ impl<U: EosUnit, E: EquationOfState> PhaseDiagramBinary<U, E> {
         let (x_lim, vle_lim, bubble) = match vle_sat {
             [None, None] => return Err(EosError::SuperCritical()),
             [Some(vle2), None] => {
-                let cp = State::critical_point_binary(eos, tp, VLEOptions::default())?;
+                let cp = State::critical_point_binary(eos, tp, SolverOptions::default())?;
                 let cp_vle = PhaseEquilibrium::from_states(cp.clone(), cp.clone());
                 ([0.0, cp.molefracs[0]], (vle2, cp_vle), bubble)
             }
             [None, Some(vle1)] => {
-                let cp = State::critical_point_binary(eos, tp, VLEOptions::default())?;
+                let cp = State::critical_point_binary(eos, tp, SolverOptions::default())?;
                 let cp_vle = PhaseEquilibrium::from_states(cp.clone(), cp.clone());
                 ([1.0, cp.molefracs[0]], (vle1, cp_vle), bubble)
             }
@@ -145,7 +145,7 @@ impl<U: EosUnit, E: EquationOfState> PhaseDiagramBinary<U, E> {
         npoints: usize,
         x_lle: (f64, f64),
         vle_sat: [Option<PhaseEquilibrium<U, E, 2>>; 2],
-        bubble_dew_options: (VLEOptions, VLEOptions),
+        bubble_dew_options: (SolverOptions, SolverOptions),
     ) -> EosResult<(
         Vec<PhaseEquilibrium<U, E, 2>>,
         Vec<PhaseEquilibrium<U, E, 2>>,
@@ -263,7 +263,7 @@ impl<U: EosUnit, E: EquationOfState> PhaseDiagramBinary<U, E> {
                 p,
                 &feed,
                 vle.as_ref(),
-                VLEOptions::default(),
+                SolverOptions::default(),
                 None,
             )
             .ok();
@@ -313,7 +313,7 @@ fn iterate_vle<U: EosUnit, E: EquationOfState>(
     vle_1: Option<PhaseEquilibrium<U, E, 2>>,
     npoints: usize,
     bubble: bool,
-    bubble_dew_options: (VLEOptions, VLEOptions),
+    bubble_dew_options: (SolverOptions, SolverOptions),
 ) -> Vec<PhaseEquilibrium<U, E, 2>>
 where
     QuantityScalar<U>: std::fmt::Display + std::fmt::LowerExp,
@@ -393,7 +393,7 @@ impl<U: EosUnit, E: EquationOfState> PhaseDiagramHetero<U, E> {
         min_temperature_lle: Option<QuantityScalar<U>>,
         npoints_vle: Option<usize>,
         npoints_lle: Option<usize>,
-        bubble_dew_options: (VLEOptions, VLEOptions),
+        bubble_dew_options: (SolverOptions, SolverOptions),
     ) -> EosResult<Self>
     where
         QuantityScalar<U>: std::fmt::Display + std::fmt::LowerExp,
@@ -421,7 +421,7 @@ impl<U: EosUnit, E: EquationOfState> PhaseDiagramHetero<U, E> {
         max_pressure_lle: Option<QuantityScalar<U>>,
         npoints_vle: Option<usize>,
         npoints_lle: Option<usize>,
-        bubble_dew_options: (VLEOptions, VLEOptions),
+        bubble_dew_options: (SolverOptions, SolverOptions),
     ) -> EosResult<Self>
     where
         QuantityScalar<U>: std::fmt::Display + std::fmt::LowerExp,
@@ -444,7 +444,7 @@ impl<U: EosUnit, E: EquationOfState> PhaseDiagramHetero<U, E> {
         tp_lim_lle: Option<QuantityScalar<U>>,
         npoints_vle: Option<usize>,
         npoints_lle: Option<usize>,
-        bubble_dew_options: (VLEOptions, VLEOptions),
+        bubble_dew_options: (SolverOptions, SolverOptions),
     ) -> EosResult<Self>
     where
         QuantityScalar<U>: std::fmt::Display + std::fmt::LowerExp,
@@ -461,14 +461,14 @@ impl<U: EosUnit, E: EquationOfState> PhaseDiagramHetero<U, E> {
                 eos,
                 t,
                 x_lle,
-                VLEOptions::default(),
+                SolverOptions::default(),
                 bubble_dew_options,
             ),
             TPSpec::Pressure(p) => PhaseEquilibrium::heteroazeotrope_p(
                 eos,
                 p,
                 x_lle,
-                VLEOptions::default(),
+                SolverOptions::default(),
                 bubble_dew_options,
             ),
         }?;
@@ -536,8 +536,8 @@ where
         eos: &Rc<E>,
         temperature: QuantityScalar<U>,
         x_init: (f64, f64),
-        options: VLEOptions,
-        bubble_dew_options: (VLEOptions, VLEOptions),
+        options: SolverOptions,
+        bubble_dew_options: (SolverOptions, SolverOptions),
     ) -> EosResult<Self> {
         // calculate initial values using bubble point
         let x1 = arr1(&[x_init.0, 1.0 - x_init.0]);
@@ -687,8 +687,8 @@ where
         eos: &Rc<E>,
         pressure: QuantityScalar<U>,
         x_init: (f64, f64),
-        options: VLEOptions,
-        bubble_dew_options: (VLEOptions, VLEOptions),
+        options: SolverOptions,
+        bubble_dew_options: (SolverOptions, SolverOptions),
     ) -> EosResult<Self> {
         let p = pressure.to_reduced(U::reference_pressure())?;
 
diff --git a/src/phase_equilibria/phase_diagram_pure.rs b/src/phase_equilibria/phase_diagram_pure.rs
index c38eb23..ca535c9 100644
--- a/src/phase_equilibria/phase_diagram_pure.rs
+++ b/src/phase_equilibria/phase_diagram_pure.rs
@@ -1,4 +1,4 @@
-use super::{PhaseEquilibrium, VLEOptions};
+use super::{PhaseEquilibrium, SolverOptions};
 use crate::equation_of_state::EquationOfState;
 use crate::errors::EosResult;
 use crate::state::{Contributions, State};
@@ -20,14 +20,14 @@ impl<U: EosUnit, E: EquationOfState> PhaseDiagramPure<U, E> {
         min_temperature: QuantityScalar<U>,
         npoints: usize,
         critical_temperature: Option<QuantityScalar<U>>,
-        options: VLEOptions,
+        options: SolverOptions,
     ) -> EosResult<Self>
     where
         QuantityScalar<U>: std::fmt::Display + std::fmt::LowerExp,
     {
         let mut states = Vec::with_capacity(npoints);
 
-        let sc = State::critical_point(eos, None, critical_temperature, VLEOptions::default())?;
+        let sc = State::critical_point(eos, None, critical_temperature, SolverOptions::default())?;
 
         let max_temperature = min_temperature
             + (sc.temperature - min_temperature) * ((npoints - 2) as f64 / (npoints - 1) as f64);
diff --git a/src/phase_equilibria/stability_analysis.rs b/src/phase_equilibria/stability_analysis.rs
index 7a7fd06..204a3d1 100644
--- a/src/phase_equilibria/stability_analysis.rs
+++ b/src/phase_equilibria/stability_analysis.rs
@@ -1,4 +1,4 @@
-use super::{PhaseEquilibrium, VLEOptions, Verbosity};
+use super::{PhaseEquilibrium, SolverOptions, Verbosity};
 use crate::equation_of_state::EquationOfState;
 use crate::errors::{EosError, EosResult};
 use crate::state::{Contributions, DensityInitialization, State};
@@ -20,14 +20,14 @@ const ZERO_TPD: f64 = -1E-08;
 impl<U: EosUnit, E: EquationOfState> State<U, E> {
     /// Determine if the state is stable, i.e. if a phase split should
     /// occur or not.
-    pub fn is_stable(&self, options: VLEOptions) -> EosResult<bool> {
+    pub fn is_stable(&self, options: SolverOptions) -> EosResult<bool> {
         Ok(self.stability_analysis(options)?.is_empty())
     }
 
     /// Perform a stability analysis. The result is a list of [State]s with
     /// negative tangent plane distance (i.e. lower Gibbs energy) that can be
     /// used as initial estimates for a phase equilibrium calculation.
-    pub fn stability_analysis(&self, options: VLEOptions) -> EosResult<Vec<State<U, E>>> {
+    pub fn stability_analysis(&self, options: SolverOptions) -> EosResult<Vec<State<U, E>>> {
         let mut result = Vec::new();
         for i_trial in 0..self.eos.components() + 1 {
             let phase = if i_trial == self.eos.components() {
@@ -94,7 +94,7 @@ impl<U: EosUnit, E: EquationOfState> State<U, E> {
     fn minimize_tpd(
         &self,
         trial: &mut State<U, E>,
-        options: VLEOptions,
+        options: SolverOptions,
     ) -> EosResult<(Option<f64>, usize)> {
         let (max_iter, tol, verbosity) = options.unwrap_or(MINIMIZE_KMAX, MINIMIZE_TOL);
         let mut newton = false;
diff --git a/src/phase_equilibria/tp_flash.rs b/src/phase_equilibria/tp_flash.rs
index d2126b8..8d188b7 100644
--- a/src/phase_equilibria/tp_flash.rs
+++ b/src/phase_equilibria/tp_flash.rs
@@ -1,4 +1,4 @@
-use super::{PhaseEquilibrium, VLEOptions, Verbosity};
+use super::{PhaseEquilibrium, SolverOptions, Verbosity};
 use crate::equation_of_state::EquationOfState;
 use crate::errors::{EosError, EosResult};
 use crate::state::{Contributions, DensityInitialization, State};
@@ -24,7 +24,7 @@ impl<U: EosUnit, E: EquationOfState> PhaseEquilibrium<U, E, 2> {
         pressure: QuantityScalar<U>,
         feed: &QuantityArray1<U>,
         init_vle_state: Option<&PhaseEquilibrium<U, E, 2>>,
-        options: VLEOptions,
+        options: SolverOptions,
         non_volatile_components: Option<Vec<usize>>,
     ) -> EosResult<Self> {
         State::new_npt(
@@ -49,7 +49,7 @@ impl<U: EosUnit, E: EquationOfState> State<U, E> {
     pub fn tp_flash(
         &self,
         init_vle_state: Option<&PhaseEquilibrium<U, E, 2>>,
-        options: VLEOptions,
+        options: SolverOptions,
         non_volatile_components: Option<Vec<usize>>,
     ) -> EosResult<PhaseEquilibrium<U, E, 2>> {
         // set options
@@ -297,7 +297,7 @@ impl<U: EosUnit, E: EquationOfState> PhaseEquilibrium<U, E, 2> {
     }
 
     fn vle_init_stability(feed_state: &State<U, E>) -> EosResult<Self> {
-        let mut stable_states = feed_state.stability_analysis(VLEOptions::default())?;
+        let mut stable_states = feed_state.stability_analysis(SolverOptions::default())?;
         let state1 = stable_states.pop();
         let state2 = stable_states.pop();
         match (state1, state2) {
diff --git a/src/phase_equilibria/vle_pure.rs b/src/phase_equilibria/vle_pure.rs
index d7d38be..5624df8 100644
--- a/src/phase_equilibria/vle_pure.rs
+++ b/src/phase_equilibria/vle_pure.rs
@@ -1,4 +1,4 @@
-use super::{PhaseEquilibrium, VLEOptions, Verbosity};
+use super::{PhaseEquilibrium, SolverOptions, Verbosity};
 use crate::density_iteration::pressure_spinodal;
 use crate::equation_of_state::EquationOfState;
 use crate::errors::{EosError, EosResult};
@@ -21,7 +21,7 @@ impl<U: EosUnit, E: EquationOfState> PhaseEquilibrium<U, E, 2> {
         eos: &Rc<E>,
         temperature: QuantityScalar<U>,
         initial_state: Option<&PhaseEquilibrium<U, E, 2>>,
-        options: VLEOptions,
+        options: SolverOptions,
     ) -> EosResult<Self>
     where
         QuantityScalar<U>: std::fmt::Display + std::fmt::LowerExp,
@@ -155,7 +155,7 @@ impl<U: EosUnit, E: EquationOfState> PhaseEquilibrium<U, E, 2> {
         eos: &Rc<E>,
         pressure: QuantityScalar<U>,
         initial_state: Option<&Self>,
-        options: VLEOptions,
+        options: SolverOptions,
     ) -> EosResult<Self>
     where
         QuantityScalar<U>: std::fmt::Display + std::fmt::LowerExp,
@@ -312,7 +312,7 @@ impl<U: EosUnit, E: EquationOfState> PhaseEquilibrium<U, E, 2> {
             vle = Some(_vle);
         }
 
-        let cp = State::critical_point(eos, None, None, VLEOptions::default())?;
+        let cp = State::critical_point(eos, None, None, SolverOptions::default())?;
         if pressure > cp.pressure(Contributions::Total) {
             return Err(EosError::SuperCritical());
         };
@@ -376,7 +376,7 @@ impl<U: EosUnit, E: EquationOfState> PhaseEquilibrium<U, E, 2> {
         (0..eos.components())
             .map(|i| {
                 let pure_eos = Rc::new(eos.subset(&[i]));
-                PhaseEquilibrium::pure_t(&pure_eos, temperature, None, VLEOptions::default())
+                PhaseEquilibrium::pure_t(&pure_eos, temperature, None, SolverOptions::default())
                     .map(|vle| vle.vapor().pressure(Contributions::Total))
                     .ok()
             })
@@ -395,7 +395,7 @@ impl<U: EosUnit, E: EquationOfState> PhaseEquilibrium<U, E, 2> {
         (0..eos.components())
             .map(|i| {
                 let pure_eos = Rc::new(eos.subset(&[i]));
-                PhaseEquilibrium::pure_p(&pure_eos, pressure, None, VLEOptions::default())
+                PhaseEquilibrium::pure_p(&pure_eos, pressure, None, SolverOptions::default())
                     .map(|vle| vle.vapor().temperature)
                     .ok()
             })
@@ -427,7 +427,7 @@ impl<U: EosUnit, E: EquationOfState> PhaseEquilibrium<U, E, 2> {
         (0..eos.components())
             .map(|i| {
                 let pure_eos = Rc::new(eos.subset(&[i]));
-                PhaseEquilibrium::pure_t(&pure_eos, temperature, None, VLEOptions::default()).ok()
+                PhaseEquilibrium::pure_t(&pure_eos, temperature, None, SolverOptions::default()).ok()
             })
             .collect()
     }
@@ -444,7 +444,7 @@ impl<U: EosUnit, E: EquationOfState> PhaseEquilibrium<U, E, 2> {
         (0..eos.components())
             .map(|i| {
                 let pure_eos = Rc::new(eos.subset(&[i]));
-                PhaseEquilibrium::pure_p(&pure_eos, pressure, None, VLEOptions::default()).ok()
+                PhaseEquilibrium::pure_p(&pure_eos, pressure, None, SolverOptions::default()).ok()
             })
             .collect()
     }
diff --git a/src/state/critical_point.rs b/src/state/critical_point.rs
index fc175b8..25abcf1 100644
--- a/src/state/critical_point.rs
+++ b/src/state/critical_point.rs
@@ -1,7 +1,7 @@
 use super::{Contributions, State, StateHD, TPSpec};
 use crate::equation_of_state::EquationOfState;
 use crate::errors::{EosError, EosResult};
-use crate::phase_equilibria::{VLEOptions, Verbosity};
+use crate::phase_equilibria::{SolverOptions, Verbosity};
 use crate::EosUnit;
 use argmin::prelude::{ArgminOp, Error, Executor};
 use argmin::solver::brent::Brent;
@@ -21,7 +21,7 @@ impl<U: EosUnit, E: EquationOfState> State<U, E> {
     pub fn critical_point_pure(
         eos: &Rc<E>,
         initial_temperature: Option<QuantityScalar<U>>,
-        options: VLEOptions,
+        options: SolverOptions,
     ) -> EosResult<Vec<Self>>
     where
         QuantityScalar<U>: std::fmt::Display,
@@ -42,7 +42,7 @@ impl<U: EosUnit, E: EquationOfState> State<U, E> {
     pub fn critical_point_binary_t(
         eos: &Rc<E>,
         temperature: QuantityScalar<U>,
-        options: VLEOptions,
+        options: SolverOptions,
     ) -> EosResult<Self>
     where
         QuantityScalar<U>: std::fmt::Display,
@@ -54,7 +54,7 @@ impl<U: EosUnit, E: EquationOfState> State<U, E> {
     pub fn critical_point_binary_p(
         eos: &Rc<E>,
         pressure: QuantityScalar<U>,
-        options: VLEOptions,
+        options: SolverOptions,
     ) -> EosResult<Self>
     where
         QuantityScalar<U>: std::fmt::Display,
@@ -65,7 +65,7 @@ impl<U: EosUnit, E: EquationOfState> State<U, E> {
     pub(crate) fn critical_point_binary(
         eos: &Rc<E>,
         tp: TPSpec<U>,
-        options: VLEOptions,
+        options: SolverOptions,
     ) -> EosResult<Self>
     where
         QuantityScalar<U>: std::fmt::Display,
@@ -78,7 +78,7 @@ impl<U: EosUnit, E: EquationOfState> State<U, E> {
             .state
             .best_param;
         let moles = arr1(&[x, 1.0 - x]) * U::reference_moles();
-        State::critical_point(eos, Some(&moles), None, VLEOptions::default())
+        State::critical_point(eos, Some(&moles), None, SolverOptions::default())
     }
 
     /// Calculate the critical point of a system for given moles.
@@ -86,7 +86,7 @@ impl<U: EosUnit, E: EquationOfState> State<U, E> {
         eos: &Rc<E>,
         moles: Option<&QuantityArray1<U>>,
         initial_temperature: Option<QuantityScalar<U>>,
-        options: VLEOptions,
+        options: SolverOptions,
     ) -> EosResult<Self>
     where
         QuantityScalar<U>: std::fmt::Display,
@@ -113,7 +113,7 @@ impl<U: EosUnit, E: EquationOfState> State<U, E> {
         eos: &Rc<E>,
         moles: &QuantityArray1<U>,
         initial_temperature: QuantityScalar<U>,
-        options: VLEOptions,
+        options: SolverOptions,
     ) -> EosResult<Self>
     where
         QuantityScalar<U>: std::fmt::Display,
@@ -262,7 +262,7 @@ where
 
     fn apply(&self, p: &Self::Param) -> Result<Self::Output, Error> {
         let moles = arr1(&[*p, 1.0 - *p]) * U::reference_moles();
-        let state = State::critical_point(&self.eos, Some(&moles), None, VLEOptions::default())?;
+        let state = State::critical_point(&self.eos, Some(&moles), None, SolverOptions::default())?;
         match self.tp {
             TPSpec::Pressure(p) => Ok(
                 (state.pressure(Contributions::Total) - p).to_reduced(U::reference_pressure())?
diff --git a/src/utils/dataset.rs b/src/utils/dataset.rs
index 22ffcf6..289884c 100644
--- a/src/utils/dataset.rs
+++ b/src/utils/dataset.rs
@@ -3,7 +3,7 @@
 //! a `target` which can be values from experimental data or
 //! other models.
 use crate::equation_of_state::{EquationOfState, MolarWeight};
-use crate::phase_equilibria::{PhaseEquilibrium, VLEOptions};
+use crate::phase_equilibria::{PhaseEquilibrium, SolverOptions};
 use crate::state::{DensityInitialization, State};
 use crate::utils::estimator::FitError;
 use crate::EosUnit;
@@ -148,7 +148,7 @@ impl<U: EosUnit, E: EquationOfState> DataSet<U, E> for VaporPressure<U> {
         QuantityScalar<U>: std::fmt::Display + std::fmt::LowerExp,
     {
         let tc =
-            State::critical_point(eos, None, Some(self.max_temperature), VLEOptions::default())
+            State::critical_point(eos, None, Some(self.max_temperature), SolverOptions::default())
                 .unwrap()
                 .temperature;
 
@@ -176,7 +176,7 @@ impl<U: EosUnit, E: EquationOfState> DataSet<U, E> for VaporPressure<U> {
         QuantityScalar<U>: std::fmt::Display + std::fmt::LowerExp,
     {
         let tc_inv = 1.0
-            / State::critical_point(eos, None, Some(self.max_temperature), VLEOptions::default())
+            / State::critical_point(eos, None, Some(self.max_temperature), SolverOptions::default())
                 .unwrap()
                 .temperature;
 
@@ -363,7 +363,7 @@ impl<U: EosUnit, E: EquationOfState + MolarWeight<U>> DataSet<U, E>
         QuantityScalar<U>: std::fmt::Display + std::fmt::LowerExp,
     {
         let tc =
-            State::critical_point(eos, None, Some(self.max_temperature), VLEOptions::default())
+            State::critical_point(eos, None, Some(self.max_temperature), SolverOptions::default())
                 .unwrap()
                 .temperature;
 
@@ -373,7 +373,7 @@ impl<U: EosUnit, E: EquationOfState + MolarWeight<U>> DataSet<U, E>
             let t: QuantityScalar<U> = self.temperature.get(i);
             if t < tc {
                 let state: PhaseEquilibrium<U, E, 2> =
-                    PhaseEquilibrium::pure_t(eos, t, None, VLEOptions::default()).unwrap();
+                    PhaseEquilibrium::pure_t(eos, t, None, SolverOptions::default()).unwrap();
                 prediction
                     .try_set(i, state.liquid().mass_density())
                     .unwrap();
@@ -389,7 +389,7 @@ impl<U: EosUnit, E: EquationOfState + MolarWeight<U>> DataSet<U, E>
         QuantityScalar<U>: std::fmt::Display + std::fmt::LowerExp,
     {
         let tc =
-            State::critical_point(eos, None, Some(self.max_temperature), VLEOptions::default())
+            State::critical_point(eos, None, Some(self.max_temperature), SolverOptions::default())
                 .unwrap()
                 .temperature;
         let n_inv = 1.0 / self.datapoints as f64;