Runs the steel code checks along every member for every strength combination, finds the governing ratio, checks the deflection limit, and finds what gives way first.
How the precision is kept
Demands are the largest station values of the member diagrams, in 64-bit numbers, divided by the code module's strength. The stations and the first-order analysis set the accuracy. Thresholds that decide whether a member carries compression or bending at all are absolute values in N and N·mm.
Calculations under this policy
12 calculations in 2 source files. The code is read from the released app when this page loads. It is the calculation people run, not a copy kept for this page.
The fy and fu used for a member from its grade and thickness.
table value; EN: the lower pair when the thickest part is over 40 mm
A table lookup with no arithmetic. The values are whole MPa as the standards print them; the code's comment notes that 345 MPa stands for 50 ksi and 250 MPa for 36 ksi.
frame/frame-design.js
lines 37 to 41
CadCraft 0.8.2
export function gradeProps(code, name, tmax = 0) {
const g = GRADES[code]?.[name];
if (!g) return null;
return code === 'en' && tmax > 40 ? { fy: g.fy40, fu: g.fu40 } : { fy: g.fy, fu: g.fu }; // EN 10025-2 Table 7: 16–40 mm / 40–80 mm
}
A diagram value between stations
64-bit
Reads a force or moment at any distance along the member from the station values.
a = aₖ + (x − xₖ) ÷ (xₖ₊₁ − xₖ) × (aₖ₊₁ − aₖ)
Straight-line interpolation between two stations; a curved diagram between stations is read as a chord. A zero station spacing is divided by 1 instead.
frame/frame-design.js
lines 77 to 85
CadCraft 0.8.2
const at = (x, a, xq) => { // linear interpolation of a series
if (xq <= x[0]) return a[0];
const n = x.length - 1;
if (xq >= x[n]) return a[n];
let k = 0;
while (x[k + 1] < xq) k++;
const f = (xq - x[k]) / (x[k + 1] - x[k] || 1);
return a[k] + f * (a[k + 1] - a[k]);
};
The diagram on one unbraced segment
64-bit
The stations inside a segment plus interpolated values at its two ends.
A station belongs to the segment when it is more than 1e-9 mm inside both ends, an absolute limit.
frame/frame-design.js
lines 86 to 93
CadCraft 0.8.2
/** The stations inside [x0, x1] plus both ends, for the named series. */
function segment(d, x0, x1, keys) {
const idx = d.x.map((v, k) => k).filter((k) => d.x[k] > x0 + 1e-9 && d.x[k] < x1 - 1e-9);
const xs = [x0, ...idx.map((k) => d.x[k]), x1];
const out = { x: xs };
for (const key of keys) out[key] = [at(d.x, d[key], x0), ...idx.map((k) => d[key][k]), at(d.x, d[key], x1)];
return out;
}
Quarter-point moments of a segment
64-bit
The largest moment of a segment and the moments at its quarter, middle and three-quarter points.
|M| at x₀ + 0.25 L, 0.5 L, 0.75 L; max |M| over the stations
The three points are read by straight-line interpolation and the maximum is the largest station value.
frame/frame-design.js
lines 94 to 98
CadCraft 0.8.2
const quart = (x, M) => { // |M| at the quarter points of a segment, and its maximum
const L = x[x.length - 1] - x[0];
const q = (f) => Math.abs(at(x, M, x[0] + f * L));
return { max: Math.max(...M.map(Math.abs)), a: q(0.25), b: q(0.5), c: q(0.75) };
};
Buckling lengths and segments of a member
64-bit
The unbraced length, the number of segments and the effective lengths used in the checks.
lb = min(L, override or ratio × L); segments = ⌈L ÷ lb − 1e-9⌉; Lcy = ky L; Lcz = kz lb; Lt = lb
Because 1e-9 is taken off before rounding up, a quotient that rounding leaves a hair above a whole number does not add a segment. The last segment ends at L exactly.
frame/frame-design.js
lines 103 to 121
CadCraft 0.8.2
/** Everything one member needs from its section, steel and bracing, before any load. */
function memberSetup(model, prep, k, design, E, G) {
const m = model.members[k];
const sec = model.sections.find((s) => s.id === m.section);
const ov = design.overrides[m.id] || {};
const base = { id: m.id, ref: m.from?.ref || '', section: sec?.name || m.section };
const shape = shapeOf(sec);
if (!shape) return { ...base, skip: 'no-shape' };
if (shape.welded) return { ...base, skip: 'welded' };
const grade = ov.grade || design.grade;
const g = gradeProps(design.code, grade, Math.max(shape.tf, shape.tw));
if (!g) return { ...base, skip: 'no-grade' };
const L = prep.mem[k].ax.L;
const lb = Math.min(L, ov.lb ?? design.lbRatio * L);
const nseg = Math.max(1, Math.ceil(L / lb - 1e-9));
const bounds = Array.from({ length: nseg + 1 }, (_, i) => Math.min(L, i * lb));
const ky = ov.ky ?? design.ky, kz = ov.kz ?? design.kz;
return { ...base, shape, sec, L, lb, bounds, ky, kz, grade, fy: g.fy, fu: g.fu, E, G, Lcy: ky * L, Lcz: kz * lb, Lt: lb };
}
Demands and ratios, AISC 360
64-bit
Collects each check's demand, capacity and ratio for one member and combination.
ratio = demand ÷ capacity; demand = largest station value
A capacity of 0 or less gives an infinite ratio. Compression counts when the axial force is below −1 N and bending when a moment exceeds 1000 N·mm; both limits are absolute. The interaction ratio is evaluated at every station of the segment and the largest kept.
Collects each check's demand, resistance and ratio for one member and combination.
ratio = demand ÷ resistance; demand = largest station value
The same absolute limits of 1 N and 1000 N·mm decide whether compression and bending act. The factor C1 passed to the lateral-torsional check is the quarter-point expression of AISC F1-1.
The factor on the governing combination at which the first member reaches a utilization of 1.
largest utilization(λ) = 1, found by solving the frame again for each λ
Each trial is a full solve and check, so the result has the accuracy of the search, which is done by the reserve function of study/breakit.js passed in as B, with an upper bound of 16 on the factor. A trial that cannot be solved counts as failed.
frame/frame-breakit.js
lines 60 to 70
CadCraft 0.8.2
// 3. the reserve on the governing combination: scale it until the first member reaches 1
let reserve = null;
if (gov) {
let n = 0;
reserve = await B.reserve(async (lam) => {
onProgress(++n);
const m2 = comboScaled(model, gov.id, lam), s2 = solveFrame(m2, { sets: [{ id: gov.id, kind: 'combo' }] });
if (!s2.ok) return Infinity;
const c2 = checkFrame(m2, s2, design);
return c2.ok ? c2.max : Infinity;
}, { cancelled, max: 16 });
Connection utilization
64-bit
The shear and axial force at a member end against the resistance the app states for the joint.
The resultant shear is one Math.hypot of the two end shears read from the Float64Array of end forces. In the finding that is shown, forces are rounded to whole N and to 0.01 kN; the utilization itself is not rounded.
frame/frame-breakit.js
lines 77 to 102
CadCraft 0.8.2
// 4. connections: member end forces of every strength combination against the resistance the app states
const notChecked = [];
const conn = [];
const strength = model.combos.filter((c) => c.limit === 'strength' && sol.results['combo:' + c.id]);
const idx = new Map(model.members.map((m, k) => [m.id, k]));
for (const c of connections) {
if (!(c.shear > 0)) { notChecked.push(c.id); continue; }
let worst = { util: 0, set: null, V: 0, N: 0 };
for (const cb of strength) {
const R = sol.results['combo:' + cb.id];
for (const e of c.ends) {
const k = idx.get(e.member);
if (k === undefined) continue;
const o = 12 * k + (e.end === 'j' ? 6 : 0);
const V = Math.hypot(R.ends[o + 1], R.ends[o + 2]), N = Math.abs(R.ends[o]);
const u = Math.max(V / c.shear, c.axial > 0 ? N / c.axial : 0);
if (u > worst.util) worst = { util: u, set: cb.id, V, N };
}
}
conn.push({ id: c.id, label: c.label || c.id, ...worst, shear: c.shear });
}
conn.sort((a, b) => b.util - a.util);
conn.forEach((c, i) => {
if (i > 0 && c.util <= 1) return;
findings.push({ id: 'connection:' + c.id, kind: 'connection', subject: { kind: 'connection', id: c.id, label: c.label }, util: c.util, factor: c.util > 0 ? 1 / c.util : null, failing: c.util > 1,
what: { set: c.set, shearKN: Math.round(c.V / 10) / 100, resistKN: Math.round(c.shear / 10) / 100 }, req: { op: '<=', value: Math.round(c.shear), unit: 'N' }, found: { value: Math.round(c.V), unit: 'N' } });
In detail
Method
Largest demand over 49 stations per member and combination; unbraced segments of equal length; utilization = demand ÷ capacity; deflection off the chord against L ÷ n. Break it scales the governing combination's factors and solves again.
Number types
64-bit numbers.
Tolerances
A member is in compression when its axial force is below −1 N and in bending when a moment exceeds 1000 N·mm (absolute). Segment bounds use 1e-9 mm. A modulus note is raised when the model's E differs from the code's by more than 0.5 %.
Limits
First-order forces. For EN 1993 the checks use E = 210 000 and G = 81 000 MPa whatever the model's steel. Yield strengths are the table values in MPa (345 MPa for 50 ksi steel, as the code's comment notes).
Approach: 64-bit, stated limit
The arithmetic is 64-bit, but the method or the data sets the accuracy: a solver tolerance, a mesh, a step size, a datum shift, a table. The limit is stated where the result is shown.