Struct MlfmmSystem 

pub struct MlfmmSystem {
    pub num_levels: usize,
    pub near_matrix: Vec<NearFieldBlock>,
    pub t_matrices: Vec<LevelMatrices>,
    pub d_matrices: Vec<Vec<DMatrixEntry>>,
    pub s_matrices: Vec<LevelMatrices>,
    pub rhs: Array1<Complex64>,
    pub num_dofs: usize,
    pub leaf_dof_indices: Vec<Vec<usize>>,
    pub sphere_points_per_level: Vec<usize>,
    /* private fields */
}

Result of MLFMM assembly

Fields

num_levels: usize

Number of levels in the tree

near_matrix: Vec<NearFieldBlock>

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

t_matrices: Vec<LevelMatrices>

T-matrices at each level (child-to-parent aggregation) Level 0 has no T-matrices (root)

d_matrices: Vec<Vec<DMatrixEntry>>

D-matrices for far-field translation at each level

s_matrices: Vec<LevelMatrices>

S-matrices at each level (parent-to-child disaggregation)

rhs: Array1<Complex64>

RHS vector

num_dofs: usize

Number of DOFs

leaf_dof_indices: Vec<Vec<usize>>

DOF mappings at leaf level: for each leaf cluster, the global DOF indices

sphere_points_per_level: Vec<usize>

Number of sphere points at each level

Implementations

impl MlfmmSystem

pub fn new( num_dofs: usize, num_levels: usize, cluster_levels: Vec<ClusterLevel>, ) -> Self

Create a new empty MLFMM system

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

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

Multi-level version with upward/downward passes.

The algorithm proceeds as follows:

1. Near-field: Direct interactions between nearby leaf clusters
2. Upward pass: Aggregate source multipoles from leaves to root (M2M translations)
3. Translation: Translate multipoles to locals between far clusters at each level (M2L)
4. Downward pass: Disaggregate local expansions from root to leaves (L2L translations)
5. Evaluation: Evaluate local expansions at leaf DOFs

Arguments

• x - Input vector (length = num_dofs)

Returns

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

pub fn get_cluster(&self, level: usize, index: usize) -> Option<&Cluster>

Get cluster at given level and index

pub fn num_clusters_at_level(&self, level: usize) -> usize

Get number of clusters at a given level