Skip to main content

SolverSelection

Enum SolverSelection 

Source
pub enum SolverSelection {
    Auto,
    Named(String),
}
Expand description

How a linear solver is chosen for a system.

§Canonical solver names

Named carries one of the registered backend names below. Unknown names are rejected with a structured SolverError — they never fall back.

namesymmetrydefinitenessintended sizeregistered by default
denseany (general)anysmallyes
skyline_ldltsymmetric onlySPD (verified)medium/largeyes
sparse_luany (general)anymedium/largeyes
cgsymmetric onlySPD (assumed)largeyes
iccgsymmetric onlySPD (assumed)largeyes
pardisoany (general)anyvery largeno — feature-gated stub

§PARDISO availability

pardiso is not registered by SolverRegistry::default(), even when the pardiso feature is compiled in: the unified PARDISO wrapper is a stub whose factor() always returns an error. Selecting it through the default registry therefore returns SolverError::Unsupported (“unknown solver”), and auto-selection never claims it is available unless a PARDISO factory is explicitly registered on the registry.

§Semantics

  • Auto: the registry analyses the matrix and picks a backend. It may substitute a different backend than any the caller had in mind.
  • Named: the request is authoritative. The registry validates capabilities and returns an error if the backend cannot legally handle the matrix. It never substitutes another backend.

skyline_ldlt, cg and iccg require positive definiteness but perform their own definiteness check during LinearSolver::factor (skyline rejects a non-positive pivot; CG/ICCG report failure). They are therefore safe to select on a symmetric matrix, but are never chosen by Auto for a matrix whose SPD property is not established.

Variants§

§

Auto

Registry-based automatic selection (default).

§

Named(String)

Explicit backend request (canonical name, see type docs).

Implementations§

Source§

impl SolverSelection

Source

pub fn named(name: impl Into<String>) -> Self

Explicit selection by canonical name.

Examples found in repository?
examples/frame_portal.rs (line 38)
13fn main() -> Result<(), Box<dyn std::error::Error>> {
14    let (e, a, i) = (200e9, 5e-3, 2e-5);
15    let (h, w) = (3.0, 4.0);
16    let lateral = 20e3; // N, +X
17    let udl = -8e3; // N/m, downward in member-local +y
18
19    // --- model -----------------------------------------------------------------
20    let mut frame = FrameModel::new();
21    let base_left = frame.add_node(0.0, 0.0)?;
22    let top_left = frame.add_node(0.0, h)?;
23    let top_right = frame.add_node(w, h)?;
24    let base_right = frame.add_node(w, 0.0)?;
25
26    let section = BeamSection::new(a, i);
27    let mat = Material::new(e, 0.3, 7850.0, "Steel");
28    let col_left = frame.add_member(base_left, top_left, mat, section)?;
29    let beam = frame.add_member(top_left, top_right, mat, section)?;
30    let col_right = frame.add_member(top_right, base_right, mat, section)?;
31
32    frame.fix(base_left)?;
33    frame.fix(base_right)?;
34    frame.nodal_load(top_left, lateral, 0.0)?; // global
35    frame.member_udl(beam, 0.0, udl)?; // local
36
37    // --- solve -----------------------------------------------------------------
38    let result = frame.solve_with(SolverSelection::named("sparse_lu"))?;
39    println!("backend              : {:?}", result.solver_name());
40    println!(
41        "nodes / members      : {} / {}",
42        result.n_nodes(),
43        result.n_members()
44    );
45
46    // --- results ---------------------------------------------------------------
47    println!(
48        "roof sway (ux)       : {:+.6e} m",
49        result.displacement(top_left, Dof::Ux)?
50    );
51    println!(
52        "base reactions       : Rx={:+.6e}  Ry={:+.6e}  Mz={:+.6e}",
53        result.reaction(base_left, Dof::Ux)?,
54        result.reaction(base_left, Dof::Uy)?,
55        result.reaction(base_left, Dof::Rz)?
56    );
57    println!(
58        "right base reaction  : Rx={:+.6e}  Ry={:+.6e}",
59        result.reaction(base_right, Dof::Ux)?,
60        result.reaction(base_right, Dof::Uy)?
61    );
62
63    // Member end forces are element-on-node forces in LOCAL axes:
64    // [N_i, V_i, M_i, N_j, V_j, M_j] = f_equiv - K_e u_e.
65    println!(
66        "beam end forces (local)  : {:?}",
67        result.member_end_forces(beam)?
68    );
69    println!(
70        "left column global ends  : {:?}",
71        result.member_end_forces_global(col_left)?
72    );
73    println!(
74        "right column global ends : {:?}",
75        result.member_end_forces_global(col_right)?
76    );
77
78    // --- equilibrium -----------------------------------------------------------
79    let eq = result.equilibrium();
80    println!(
81        "equilibrium residual : sumFx={:+.3e}  sumFy={:+.3e}  sumMz={:+.3e}  (about the origin)",
82        eq.fx_residual, eq.fy_residual, eq.mz_residual
83    );
84    println!("balanced             : {}", eq.is_balanced());
85
86    Ok(())
87}
Source

pub fn dense() -> Self

Select the dense Gaussian backend.

Source

pub fn skyline_ldlt() -> Self

Select the skyline LDL^T backend (symmetric SPD).

Source

pub fn sparse_lu() -> Self

Select the sparse LU backend.

Source

pub fn cg() -> Self

Select the conjugate-gradient backend (symmetric SPD).

Source

pub fn iccg() -> Self

Select the incomplete-Cholesky CG backend (symmetric SPD).

Source

pub fn pardiso() -> Self

Select the PARDISO backend.

Not available through SolverRegistry::default() — PARDISO is a feature-gated stub that is deliberately left unregistered, so this selection resolves only if a PARDISO factory is explicitly registered via SolverRegistry::register. Otherwise SolverRegistry::create_selected returns SolverError::Unsupported rather than silently falling back.

Source

pub fn is_auto(&self) -> bool

Whether this is automatic selection.

Source

pub fn requested_name(&self) -> Option<&str>

The explicitly requested name, or None for SolverSelection::Auto.

Trait Implementations§

Source§

impl Clone for SolverSelection

Source§

fn clone(&self) -> Self

Returns a duplicate of the value. Read more
1.0.0 (const: unstable) · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
Source§

impl Debug for SolverSelection

Source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
Source§

impl Default for SolverSelection

Source§

fn default() -> Self

Returns the “default value” for a type. Read more
Source§

impl Eq for SolverSelection

Source§

impl PartialEq for SolverSelection

Source§

fn eq(&self, other: &Self) -> bool

Equality operator ==. Read more
1.0.0 (const: unstable) · Source§

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=. Read more
Source§

impl StructuralPartialEq for SolverSelection

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = !

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, !>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.