Struct GapPatch 

pub struct GapPatch {
    pub pairs: usize,
    pub span: (f64, f64),
    pub distance: f64,
    pub rectangular: bool,
}

One patch of a clearance: two facing surfaces and how far apart they are.

A gap is found pair by pair, along one axis, one cell face against the one directly across from it. A patch is what those pairs add up to — a connected sheet of facing area at one separation, which is the shape a view factor is a statement about.

Fields

pairs: usize

How many facing cell pairs are in it.

span: (f64, f64)

The patch’s extent across the gap, in metres — the bounding box of the facing cells.

distance: f64

How far the two surfaces are apart, in metres.

rectangular: bool

Whether the facing cells fill their bounding box.

view_factor is exact for a rectangle and an upper bound for anything else, because a patch with a bite out of it sees less of itself than its bounding box does. Reported rather than corrected: an L-shaped clearance is not a shape the closed form covers, and a number invented for it would be worth less than knowing it is a bound.

Implementations

impl GapPatch

pub fn view_factor(&self) -> f64

The view factor from one of the facing surfaces to the other, F₁₂.

The exact closed form for two equal, parallel, directly-opposed rectangles — which is the geometry the pairing produces by construction, since a pair is a cell and the cell across from it. With X = a/c and Y = b/c:

F = 2/(πXY) · [ ln √((1+X²)(1+Y²)/(1+X²+Y²))
                + X√(1+Y²)·atan(X/√(1+Y²)) + Y√(1+X²)·atan(Y/√(1+X²))
                − X·atan X − Y·atan Y ]

This is not what the exchange is charged, and the difference is the point. What the block charges is F̄ = 1, which is exact when the sides of the gap are mirrors — and the block’s own outer faces are exactly that, because an insulated boundary is implemented as a mirror and a mirror extends the two surfaces to infinity. F₁₂ is what the same pair would exchange with nothing at the sides, open to space. The two agree when the gap is narrow compared with the surfaces and diverge without limit when it is not, so this is the number that says how much of the answer is resting on reading the boundary one way.

Trait Implementations

impl Clone for GapPatch

fn clone(&self) -> GapPatch

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for GapPatch

impl Debug for GapPatch

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

Formats the value using the given formatter.

impl PartialEq for GapPatch

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for GapPatch