Enum RobustLoss 

pub enum RobustLoss {
    Tukey,
    Huber,
}

How a standardised residual becomes a weight.

Measured on the four-echo 7 T phantom, one echo given a slab dropout plus a phase scramble. “Clean-series cost” is how far the robust fit moves the field map when there is nothing wrong — the price of insurance; “corrupted-series error” is how far the field map sits from the clean answer when there is. Both are relative errors against the plain magnitude-weighted fit of the clean data.

	clean-series cost	corrupted-series error	flagged the right echo
no robust fit at all	0 by definition	0.0424	—
Huber at c = 1.345	0.0142	0.0304	yes
Tukey at c = 4.685	0.0059	0.0268	yes
Tukey with the degeneracy guard removed	—	0.320	yes

The last row is why multi_echo_robust_fit has that guard, and the reason the obvious a-priori argument — that a rejecting loss must be wrong for a four-echo train, because throwing an echo away leaves three points to fit two parameters — is only half right. It is exactly right about the danger and wrong about the remedy: the fix is to stop the fit becoming under-determined, not to stop rejecting.

Variants

Tukey

w = (1 - u²)² inside the tuning radius and zero outside: an outlier past the radius is discarded entirely. Conventional tuning constant 4.685.

The default, on the evidence above — it both protects a corrupted series better and disturbs a clean one less, because it leaves everything inside the radius at full weight instead of shading the whole distribution the way Huber’s tail does.

Huber

w = 1 inside the tuning radius, w = c/|u| outside: an outlier’s influence is capped but never removed. Conventional tuning constant 1.345.

Never rejects, so EchoQuality::rejected_fraction is always zero and the fit can never become under-determined no matter how the data behaves. Worth choosing when that guarantee is worth more than the accuracy, or on a series short enough that the guard would be firing constantly.

Implementations

impl RobustLoss

pub fn conventional_tuning(self) -> f64

The conventional tuning constant for this loss — Tukey 4.685, Huber 1.345, both the values that give 95% efficiency against purely Gaussian noise.

Used when RobustFitParams::tuning is None. On the phantom above these are also where the corrupted-series error bottoms out, so there is no tension between the textbook choice and the measured one: for Tukey the sweep gave 0.0397 / 0.0341 / 0.0268 / 0.0289 / 0.0361 at c = 2.5 / 3.5 / 4.685 / 6 / 8.

fn weight(self, u: f64) -> f64

Weight for a residual already divided by tuning × scale.

Trait Implementations

impl Clone for RobustLoss

fn clone(&self) -> RobustLoss

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for RobustLoss

impl Debug for RobustLoss

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

Formats the value using the given formatter.

impl Default for RobustLoss

fn default() -> RobustLoss

Returns the “default value” for a type.

impl Eq for RobustLoss

impl PartialEq for RobustLoss

fn eq(&self, other: &RobustLoss) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for RobustLoss

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RobustLoss