Struct FieldResidual 

pub struct FieldResidual {
    pub(super) vectors: Vec<[Complex; 3]>,
    pub(super) polarizations: Vec<u8>,
    pub(super) points: Vec<[f64; 3]>,
    pub(super) coefficients: Option<Vec<Complex>>,
    pub(super) helicity: bool,
    pub(super) fixed_vectors: bool,
}

What field saves for its pullback: its inputs, for weighted fields or for the matrix that samples every mode.

The pullback splits the longer of the point and mode axes into at most 32 blocks, fixed by the shape, as PhasesResidual::pullback does. Each block writes the gradients of its own points or modes and a partial sum of the gradients of the other axis, and the partial sums add in block order; a mode’s polarization pulls back once, from its total over all points. The blocks run in parallel from 4096 points times modes (PARALLEL_ENTRIES), and in the same order on the calling thread below, so the thread count does not change the result.

Fields

vectors: Vec<[Complex; 3]>

polarizations: Vec<u8>

points: Vec<[f64; 3]>

coefficients: Option<Vec<Complex>>

helicity: bool

fixed_vectors: bool

Implementations

impl FieldResidual

pub fn coefficient_count(&self) -> usize

Number of weighted amplitudes, or zero for a field operator.

pub fn shape(&self) -> (usize, usize)

Flattened output dimensions (3 * samples, modes or one weighted column).

pub fn validate_tangents( &self, coefficients: &[Complex], points: &[[f64; 3]], vectors: &[[Complex; 3]], ) -> Result<()>

Validate amplitude, sample-point and wavevector tangents. An operator takes an empty amplitude tangent because it has no amplitude input.

pub fn pushforward( &self, coefficients: &[Complex], points: &[[f64; 3]], vectors: &[[Complex; 3]], ) -> Result<DMatrix<Complex>>

Push one direction through the amplitudes, phases and polarizations. Each mode’s polarization derivative is contracted once and reused at every point.

pub fn pullback(&self, cotangent: &DMatrix<Complex>) -> Result<FieldGradient>

Gradients for a cotangent of the field’s shape. The pullback recomputes the polarization and phase derivatives instead of storing a dense field Jacobian.

fn mode(&self, j: usize, variable: bool) -> Result<ModeTerms>

The wavevector, polarization jet and amplitude of plane mode j.

fn rows<'c>( &self, cotangent: &'c DMatrix<Complex>, j: usize, ) -> &'c [[Complex; 3]]

The three Cartesian cotangents of each sample, contiguous in the cotangent column of mode j, or in the one column of a weighted field.

fn contract( &self, mode: &ModeTerms, points: &[[f64; 3]], rows: &[[Complex; 3]], point_gradients: &mut [[f64; 3]], sums: &mut ModeSums, )

Add the terms of mode at points, whose cotangents are rows, to the point gradients point_gradients and to the mode’s sums, in point order.

fn finish( &self, mode: &ModeTerms, sums: &ModeSums, coefficient: Option<&mut Complex>, vector: &mut [Complex; 3], )

Write the amplitude gradient coefficient (none for an operator) and the wavevector gradient vector of mode from its sums over all points.

impl FieldResidual

pub fn state_size(points: usize, modes: usize, weighted: bool) -> Result<usize>

Byte count for plane fields; weighted fields retain one amplitude per mode.

Trait Implementations

impl Debug for FieldResidual

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

Formats the value using the given formatter.

impl SavedState for FieldResidual

fn save_state(&self) -> Result<Vec<u8>>

Copy the saved numerical state into its fixed byte layout.

fn from_state(bytes: &[u8]) -> Result<Self>

Restore numerical state from bytes produced by this extension.