Struct FaceVectorArea 

pub struct FaceVectorArea {
    pub shell: u64,
    pub face: u64,
    pub face_name: Option<String>,
    pub trim: Vec3,
    pub edge: Vec3,
    pub departure: Vec3,
    pub boundary_length: f64,
    pub bar: f64,
    pub closure_gap: f64,
}

One face’s vector area ∫ n dA, as its TRIMS claim it and as its EDGES claim it, and the difference between the two.

Both are the same boundary integral (1/2) ∮ (r − R) × dr about the shell’s own reference R (see ShellVectorArea::reference), over the same loops in the same order; only the curve differs. The trim walks the pcurve mapped through this face’s surface — the boundary the mass integrals actually integrate over — and the edge walks the 3D edge curve the coedge names, which is the SAME curve the face across that edge walks.

Fields

shell: u64

face: u64

face_name: Option<String>

trim: Vec3

(1/2) ∮ (r − R) × dr over the face’s TRIMS, each coedge sampled in its own parameter direction (a pcurve is parameterized in its coedge’s traversal direction, so the loop is walked by sampling each pcurve forwards, never by reversing a reverse coedge’s sweep).

edge: Vec3

The same integral over the 3D EDGE curves, each edge traversed in its coedge’s direction — forwards over [t0, t1] for a forward coedge, backwards for a reverse one.

departure: Vec3

trim − edge: what THIS face’s trims add to the shell’s residual. Every edge term cancels across the shell (each edge is walked once each way), so the shell’s residual is exactly the sum of these.

boundary_length: f64

The face’s own boundary arc length, taken on the edge curves.

bar: f64

PCURVE_REFINEMENT_TOLERANCE * boundary_length — what this face’s departure can be while every one of its trims lies within the fit floor of the edge it claims. See ShellVectorArea::bar for the derivation; this is the same bound applied to one loop.

It does not cover a face whose closure_gap is over the floor. The derivation takes one integration by parts over a CLOSED loop; a loop that does not close carries a boundary term the bound never modelled, and the sliver its chords span is real area that this face’s trims genuinely enclose. Read closure_gap first.

closure_gap: f64

How far this face’s own trims fail to MEET each other: the summed 3D distance from where one coedge’s trim ends to where the next one starts, over this face’s loops, including the chord home.

A different defect from the departure, and the one that is easy to misread as it. Two trims arriving at one vertex are fitted independently, each refined to PCURVE_REFINEMENT_TOLERANCE, so they can miss each other by twice it — about 2e-7 — and anything at that scale is the fit floor rather than a defect. Past it the loop is not closed in the record, and then this face’s departure is partly the area of the sliver its closing chords span rather than any trim lying off an edge.

Reported, not verdicted: a bar on it would be a new tolerance, and the slice that owns a loop’s closure is the one that opens it. On the notched cap (2026-09-16) the top cap E5:S4:PROFILE:L2_END carries a 4.095e-7 net step in uv while every other loop on that shell closes to 1e-12 or better, and it is the fillet that opens it — the same document’s pre-fillet body closes exactly.

Implementations

impl FaceVectorArea

pub fn residual(&self) -> f64

|departure|.

pub fn is_over_bar(&self) -> bool

Does this face’s trim lie further from its own edges than a fit at the refinement floor can account for?

Trait Implementations

impl Clone for FaceVectorArea

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FaceVectorArea

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

Formats the value using the given formatter.

impl Serialize for FaceVectorArea

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

where __S: Serializer,

Serialize this value into the given Serde serializer.