Struct TranslationPlan 

pub(crate) struct TranslationPlan {
    terms: Vec<Term>,
    starts: Vec<usize>,
    lmax: i32,
    solids: SolidTable,
}

Geometry-independent spherical mode couplings, shared across position pairs.

Fields

terms: Vec<Term>

Terms of all entries, entry e in terms[starts[e]..starts[e + 1]].

starts: Vec<usize>

lmax: i32

Largest harmonic degree: the largest destination plus the largest source degree.

solids: SolidTable

Implementations

impl TranslationPlan

pub(crate) fn between( destination: &[Mode], source: &[Mode], helicity: bool, ) -> Result<Self>

The couplings from the source modes to the destination modes, in helicity or parity polarization.

pub(crate) fn weights_for_normalized_harmonics(&mut self)

Divide each weight by the normalization N_pm of its harmonic (crate::special::harmonic_normalization). The plan then sums its weights against tables of orthonormal-harmonic values N_pm z_p P_p^m e^(i m phi), the normalization of the lattice sums of crate::lattice::sum, instead of z_p P_p^m e^(i m phi).

fn entries(&self) -> impl Iterator<Item = &[Term]>

The terms of each block entry, column-major (source outer, destination inner).

pub(crate) fn evaluate_table(&self, table: &[Complex]) -> Vec<Complex>

The block, column-major, from harmonic values table at index p * p + p + m.

pub(crate) fn pullback_table( &self, cotangent: &[Complex], table: &mut [Complex], )

Add the block cotangent, weighted by the conjugate term weights, to the harmonic cotangents table.

fn radials(&self, z: Complex, radial: Radial) -> Result<Vec<RadialJet>>

Radial jets z_p(z) of degrees p = 0..=lmax.

fn values( &self, k: Complex, position: [f64; 3], radial: Radial, ) -> Result<Vec<Complex>>

Harmonic table z_p(k r) P_p^m(cos theta) e^(i m phi) at index p * p + p + m. Outgoing waves vanish at the origin, where only the regular p = 0 term survives.

fn table( &self, k: Complex, position: [f64; 3], radial: Radial, ) -> Result<Vec<CartesianTranslation>>

Harmonic table with the displacement and wavenumber derivatives of each entry.

pub(crate) fn evaluate( &self, k: Complex, position: [f64; 3], radial: Radial, ) -> Result<Vec<Complex>>

The block of regular or singular translation coefficients at the displacement position, column-major (source outer, destination inner).

pub(crate) fn apply( &self, k: Complex, position: [f64; 3], radial: Radial, input: MatRef<'_, Complex>, output: MatMut<'_, Complex>, adjoint: bool, ) -> Result<()>

Add the translation applied to input to output, sharing each coefficient across the input columns without storing a dense block. With adjoint, apply its conjugate transpose instead. The row counts follow the plan’s source and destination modes, exchanged for the adjoint.

pub(crate) fn apply_pushforward( &self, k: Complex, position: [f64; 3], radial: Radial, position_tangent: [f64; 3], k_tangent: Complex, input: MatRef<'_, Complex>, output: MatMut<'_, Complex>, ) -> Result<()>

Apply the directional derivative of a translation directly to its incident columns, without allocating a dense particle-pair block.

fn apply_table( &self, table: &[Complex], input: MatRef<'_, Complex>, output: MatMut<'_, Complex>, adjoint: bool, )

A value or tangent harmonic table, shared over all incident columns.

fn harmonic_groups(&self, workers: usize) -> Vec<(i32, RangeInclusive<i32>)>

Cache-sharing groups in harmonic order. Whole degrees retain the most reuse; when a block has more workers than degrees, consecutive orders expose enough independent work to use that budget. Grouping changes no harmonic’s arithmetic.

pub(crate) fn evaluate_periodic( &self, k: Complex, position: [f64; 3], lattice: &BlochLattice, eta: Complex, workers: usize, ) -> Result<Vec<Complex>>

The block of lattice-summed couplings at the displacement position (destination minus source). The lattice sums take source - destination.

pub(crate) fn pushforward_periodic( &self, ks: [Complex; 2], position: [f64; 3], lattice: &BlochLattice, eta: Complex, tangents: &[SumTangent; 2], workers: usize, ) -> Result<[Vec<Complex>; 2]>

Apply the angular plan to directional lattice-sum derivatives. Equal medium wavenumbers share their Ewald jets even when their input directions differ.

pub(crate) fn pullback_periodic( &self, ks: [Complex; 2], position: [f64; 3], lattice: &BlochLattice, eta: Complex, cotangent: &[Vec<Complex>; 2], workers: usize, ) -> Result<[SumGradient; 2]>

The lattice-sum gradients of the block cotangents of both polarizations.

Cache-sharing groups adapt to the worker budget, but their gradients are collected and added in harmonic order, so the thread count does not change them.

pub(crate) fn pushforward( &self, k: Complex, position: [f64; 3], radial: Radial, position_tangent: [f64; 3], k_tangent: Complex, ) -> Result<Vec<Complex>>

Contract the shared harmonic derivatives before assembling the block.

fn tangent_table( &self, k: Complex, position: [f64; 3], radial: Radial, position_tangent: [f64; 3], k_tangent: Complex, ) -> Result<Vec<Complex>>

Contract derivatives before expanding harmonic coefficients into mode pairs.

pub(crate) fn pullback( &self, k: Complex, position: [f64; 3], radial: Radial, cotangent: &[Complex], ) -> Result<([f64; 3], Complex)>

Pull a block cotangent of evaluate back to the real displacement gradient and the complex wavenumber cotangent.

Trait Implementations

impl Clone for TranslationPlan

fn clone(&self) -> TranslationPlan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TranslationPlan

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

Formats the value using the given formatter.