Struct SlfmmSystem 

pub struct SlfmmSystem {
    pub near_matrix: Vec<NearFieldBlock>,
    pub t_matrices: Vec<Array2<Complex64>>,
    pub t_vector: Array1<Complex64>,
    pub d_matrices: Vec<DMatrixEntry>,
    pub s_matrices: Vec<Array2<Complex64>>,
    pub rhs: Array1<Complex64>,
    pub num_dofs: usize,
    pub num_sphere_points: usize,
    pub num_expansion_terms: usize,
    pub num_clusters: usize,
    pub cluster_dof_indices: Vec<Vec<usize>>,
}

Result of SLFMM assembly

Fields

near_matrix: Vec<NearFieldBlock>

Near-field coefficient matrix (sparse, stored as dense blocks)

t_matrices: Vec<Array2<Complex64>>

T-matrix for each cluster (element DOFs → multipole expansion)

t_vector: Array1<Complex64>

T-vector for RHS contribution

d_matrices: Vec<DMatrixEntry>

D-matrix entries for far cluster pairs

s_matrices: Vec<Array2<Complex64>>

S-matrix for each cluster (multipole expansion → field DOFs)

rhs: Array1<Complex64>

RHS vector

num_dofs: usize

Number of DOFs

num_sphere_points: usize

Number of integration points on unit sphere

num_expansion_terms: usize

Number of expansion terms

num_clusters: usize

Number of clusters

cluster_dof_indices: Vec<Vec<usize>>

Cluster DOF mappings: for each cluster, the global DOF indices

Implementations

impl SlfmmSystem

pub fn new( num_dofs: usize, num_clusters: usize, num_sphere_points: usize, num_expansion_terms: usize, ) -> Self

Create a new empty SLFMM system

pub fn extract_near_field_matrix(&self) -> Array2<Complex64>

Extract the near-field matrix as a dense matrix for preconditioning

This assembles only the near-field blocks into a dense matrix, which is much smaller than the full matrix (O(N) vs O(N²) entries).

pub fn matvec(&self, x: &Array1<Complex64>) -> Array1<Complex64>

Apply the SLFMM operator: y = ([N] + [S][D][T]) * x

This is used in iterative solvers (CGS, BiCGSTAB).

The decomposition is:

• Near-field: Direct element-to-element interactions for nearby clusters
• Far-field: Multipole expansions with SDT factorization

Arguments

• x - Input vector (length = num_dofs)

Returns

• y - Output vector (length = num_dofs), y = A*x

pub fn matvec_transpose(&self, x: &Array1<Complex64>) -> Array1<Complex64>

Apply the SLFMM operator transpose: y = A^T * x (parallelized)

Used by some iterative solvers (e.g., BiCGSTAB).