Struct HtPoisson 

pub struct HtPoisson {
    pub shape: [usize; 3],
    pub dx: [f64; 3],
    /* private fields */
}

HT-format Poisson solver for isolated BCs.

Pre-computes the exponential sum coefficients and the per-term 1D Fourier factors so that each solve() only needs: from_dense → pad → FFT → multiply → sum → IFFT → truncate → extract.

Fields

shape: [usize; 3]

Spatial grid dimensions [N0, N1, N2] of the original (unpadded) domain.

dx: [f64; 3]

Grid spacing [dx0, dx1, dx2] in each spatial direction.

Implementations

impl HtPoisson

pub fn new( shape: [usize; 3], dx: [f64; 3], exp_sum_accuracy: f64, tolerance: f64, max_rank: usize, ) -> Self

Create a new HtPoisson solver.

Computes the Braess-Hackbusch exponential sum for 1/r, then precomputes the per-term 1D FFT of each Gaussian factor and caches leaf FFT plans. Subsequent solve() calls only perform the HT convolution pipeline.

• shape: spatial grid dimensions [N0, N1, N2].
• dx: grid spacing in each direction.
• exp_sum_accuracy: target accuracy for the exponential sum.
• tolerance: truncation tolerance for HT compression of the density.
• max_rank: maximum HT rank after truncation.

pub fn from_domain( domain: &Domain, exp_sum_accuracy: f64, tolerance: f64, max_rank: usize, ) -> Self

Create from a Domain, extracting shape and dx automatically.

pub fn last_rank_info(&self) -> Option<(Vec<usize>, Vec<usize>)>

Per-step rank diagnostics: returns (pre_truncation_ranks, post_truncation_ranks).

pub fn with_near_field_enabled(self, enabled: bool) -> Self

Enable or disable the near-field correction (builder pattern).

pub fn last_near_field_magnitude(&self) -> f64

Return the L2 norm of the most recent near-field correction.

Returns 0.0 if no solve has been performed yet or if the correction is disabled.

Trait Implementations

impl PoissonSolver for HtPoisson

fn solve(&self, density: &DensityField, g: f64) -> PotentialField

Solve the Poisson equation via HT-format convolution with the exp-sum Green’s function.

Pipeline: zero-pad rho -> HT decomposition -> FFT leaves -> multiply each of R_G Gaussian terms as rank-1 diagonal scaling -> sum -> IFFT leaves -> truncate -> extract N^3 subgrid -> apply near-field corrections.

fn compute_acceleration(&self, potential: &PotentialField) -> AccelerationField

Compute acceleration g = -grad(Phi) via second-order centered finite differences.

fn set_progress(&mut self, p: Arc<StepProgress>)

Attach shared progress state for intra-phase cell-level reporting.