@theerapat-s28/ts-structural-eng-tools 3.1.0 → 3.2.0

package/dist/fea/{frame → analysis}/solver/load-case-solver.d.ts

@@ -1,6 +1,8 @@
-import { type LocalMemberLoad } from "../elements/fixed-end-forces";
-import type { AreaLoad, LoadCase, MemberLoad, NodalLoad } from "../types/model.type";
-import type { FrameSystem } from "./frame-system";
+import { type LocalMemberLoad } from "../../frame/elements/fixed-end-forces";
+import type { MemberLoad } from "../../frame/types/model.type";
+import type { AreaLoad } from "../../shared/types/model.type";
+import type { LoadCase, NodalLoad } from "../types/model.type";
+import type { AnalysisSystem } from "./analysis-system";
 /**
  * Unrounded result of one load case or combination, in N and mm. Every field is linear in the
  * loads, so combinations are formed by factoring and adding states.
@@ -16,24 +18,18 @@ export interface RawState {
 /**
  * Solves one load case against the prepared, factorised system.
  *
- * Self-weight is `selfWeight · unitWeight · A` per unit member length along global −Z.
+ * Members take their loads and self-weight as fixed-end forces (see `memberPieceLoads`); shells
+ * take their area loads and self-weight as forces at their corners (see `addShellLoads`).
  *
  * @param loadCase - The load case (id and self-weight multiplier)
- * @param loads - The nodal and member loads tagged with this load case
- *
- * Shell areas take `selfWeight · unitWeight · thickness · modifiers.weight` per unit area along
- * −Z and their `AreaLoad`s as forces at their corners, each corner the share `∫ Nᵢ dA` of the
- * element's area on its mean plane (no corner moments, so a warped element's offsets do not load
- * the rotations auto-restraint holds).
- *
  * @param loads - The nodal and member loads tagged with this load case, and its area loads on
  *   shell areas
  *
- * @throws {FrameAnalysisError} 304 if a load has a moment about a joint rotation that nothing
+ * @throws {FeaError} 304 if a load has a moment about a joint rotation that nothing
  *   resists (an auto-restrained axis), 308 for a load outside its member, 313 if self-weight is
  *   requested for a member without `unitWeight`
  */
-export declare const solveLoadCase: (system: FrameSystem, loadCase: LoadCase, loads: {
+export declare const solveLoadCase: (system: AnalysisSystem, loadCase: LoadCase, loads: {
     nodalLoads: NodalLoad[];
     memberLoads: MemberLoad[];
     shellLoads?: AreaLoad[];

package/dist/fea/analysis/solver/load-case-solver.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.combineStates = exports.solveLoadCase = void 0;
+const frame_constant_1 = require("../../../core/constants/frame.constant");
+const fea_error_1 = require("../../../core/errors/fea.error");
+const fixed_end_forces_1 = require("../../frame/elements/fixed-end-forces");
+const member_assembly_1 = require("../../frame/solver/member-assembly");
+const member_loads_1 = require("../../frame/solver/member-loads");
+const global_assembly_1 = require("../../shared/solver/global-assembly");
+const issues_1 = require("../../shared/validation/issues");
+const shell_forces_1 = require("../../shell/post/shell-forces");
+const shell_loads_1 = require("../../shell/solver/shell-loads");
+const matrix_1 = require("../../../utils/matrix");
+const skyline_1 = require("../../../utils/skyline");
+/**
+ * Solves one load case against the prepared, factorised system.
+ *
+ * Members take their loads and self-weight as fixed-end forces (see `memberPieceLoads`); shells
+ * take their area loads and self-weight as forces at their corners (see `addShellLoads`).
+ *
+ * @param loadCase - The load case (id and self-weight multiplier)
+ * @param loads - The nodal and member loads tagged with this load case, and its area loads on
+ *   shell areas
+ *
+ * @throws {FeaError} 304 if a load has a moment about a joint rotation that nothing
+ *   resists (an auto-restrained axis), 308 for a load outside its member, 313 if self-weight is
+ *   requested for a member without `unitWeight`
+ */
+const solveLoadCase = (system, loadCase, loads) => {
+    const { members, dofCount, boundary, equation, free, factor, nodeIndex, memberIndex } = system;
+    const F = new Array(dofCount).fill(0);
+    const selfWeight = loadCase.selfWeight ?? 0;
+    const memberLoads = (0, member_loads_1.memberPieceLoads)(system.memberGroups, members, memberIndex, loads.memberLoads, loadCase.id, selfWeight);
+    const fixed = members.map((member, m) => {
+        const condensed = member.condenseFixedEndForces((0, fixed_end_forces_1.fixedEndForces)(memberLoads[m], member.length));
+        (0, member_assembly_1.scatterMemberForces)(F, member, condensed, -1);
+        return condensed;
+    });
+    // Shell surface loads as forces at the element corners
+    (0, shell_loads_1.addShellLoads)(F, system.shells, system.shellsByArea, loads.shellLoads ?? [], selfWeight);
+    for (const load of loads.nodalLoads) {
+        const base = 6 * nodeIndex.get(load.nodeId);
+        [load.fx, load.fy, load.fz].forEach((v, k) => (F[base + k] += (v ?? 0) * 1e3));
+        [load.mx, load.my, load.mz].forEach((v, k) => (F[base + 3 + k] += (v ?? 0) * 1e6));
+    }
+    // A held rotation axis is decoupled from the structure: a moment about it has no load path.
+    let momentScale = 0;
+    for (let n = 0; n < system.nodes.length; n++) {
+        for (let k = 3; k < 6; k++)
+            momentScale = Math.max(momentScale, Math.abs(F[6 * n + k]));
+    }
+    for (const { node, axis } of system.autoRestraints) {
+        const moment = axis.reduce((sum, a, i) => sum + a * F[6 * node + 3 + i], 0);
+        if (Math.abs(moment) > frame_constant_1.SINGULARITY_TOLERANCE * momentScale) {
+            const lead = axis.reduce((best, a, i) => (Math.abs(a) > Math.abs(axis[best]) ? i : best), 0);
+            (0, issues_1.throwIssues)([
+                (0, issues_1.modelIssue)(fea_error_1.FeaErrors.STRUCTURE_UNSTABLE, {
+                    nodeId: system.nodes[node].id,
+                    dof: ["rx", "ry", "rz"][lead],
+                    loadCaseId: loadCase.id,
+                }),
+            ]);
+        }
+    }
+    const U = new Array(dofCount).fill(0);
+    if (factor) {
+        const solution = (0, skyline_1.skylineSolve)(factor, free.map((dof) => F[dof]));
+        free.forEach((dof) => (U[dof] = solution[equation[dof]]));
+    }
+    // Elastic end forces k·u per member; their global sum is K·U, from which R = K·U − F
+    const KU = new Array(dofCount).fill(0);
+    const memberForces = members.map((member, m) => {
+        const uLocal = (0, matrix_1.matVec)(member.T, (0, member_assembly_1.memberDofs)(member).map((d) => U[d]));
+        const elastic = (0, matrix_1.matVec)(member.k, uLocal);
+        (0, member_assembly_1.scatterMemberForces)(KU, member, elastic, 1);
+        return elastic.map((v, i) => v + fixed[m][i]);
+    });
+    for (const shell of system.shells) {
+        const dofs = (0, global_assembly_1.elementDofs)(shell.nodeIndices);
+        const forces = (0, matrix_1.matVec)(shell.element.kGlobal, dofs.map((d) => U[d]));
+        dofs.forEach((d, a) => (KU[d] += forces[a]));
+    }
+    const R = KU.map((v, i) => (boundary.restrained[i] ? v - F[i] : 0));
+    const shellForces = system.shells.map((shell) => (0, shell_forces_1.shellRawForces)(shell, U));
+    return { U, R, F, memberForces, shellForces, memberLoads };
+};
+exports.solveLoadCase = solveLoadCase;
+/** Superposes factored states: `Σ factor × state`. Member loads are concatenated, scaled. */
+const combineStates = (terms) => {
+    const first = terms[0].state;
+    const add = (pick, length) => {
+        const out = new Array(length).fill(0);
+        for (const { state, factor } of terms) {
+            pick(state).forEach((v, i) => (out[i] += factor * v));
+        }
+        return out;
+    };
+    return {
+        U: add((s) => s.U, first.U.length),
+        R: add((s) => s.R, first.R.length),
+        F: add((s) => s.F, first.F.length),
+        memberForces: first.memberForces.map((_, m) => add((s) => s.memberForces[m], 12)),
+        shellForces: first.shellForces.map((f, sh) => add((s) => s.shellForces[sh], f.length)),
+        memberLoads: first.memberLoads.map((_, m) => terms.flatMap(({ state, factor }) => factor === 0 ? [] : state.memberLoads[m].map((l) => (0, member_loads_1.scaleMemberLoad)(l, factor)))),
+    };
+};
+exports.combineStates = combineStates;
+//# sourceMappingURL=load-case-solver.js.map

package/dist/fea/analysis/solver/load-case-solver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-case-solver.js","sourceRoot":"","sources":["../../../../src/fea/analysis/solver/load-case-solver.ts"],"names":[],"mappings":"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"}

package/dist/fea/analysis/types/model.type.d.ts

@@ -0,0 +1,80 @@
+import type { Member, MemberLoad, NullArea } from "../../frame/types/model.type";
+import type { AreaLoad, FeaId, FeaNode, Restraint } from "../../shared/types/model.type";
+import type { ShellArea } from "../../shell/types/model.type";
+/**
+ * Fixed DOFs along a straight line: every node on the segment between two nodes, including the
+ * nodes the engine generates when it meshes shell areas, e.g. a wall base fixed along its
+ * length. `true` fixes the DOF; there are no line springs. Combined with point restraints at
+ * the same node, a fixed DOF stays fixed.
+ */
+export interface LineRestraint {
+    nodeIds: [FeaId, FeaId];
+    ux?: boolean;
+    uy?: boolean;
+    uz?: boolean;
+    rx?: boolean;
+    ry?: boolean;
+    rz?: boolean;
+}
+export interface NodalLoad {
+    loadCase: string;
+    nodeId: FeaId;
+    fx?: number;
+    fy?: number;
+    fz?: number;
+    mx?: number;
+    my?: number;
+    mz?: number;
+}
+/** Descriptive category of a load case; it labels the case and does not change the analysis. */
+export type LoadCaseType = "dead" | "superDead" | "live" | "roofLive" | "snow" | "wind" | "seismic" | "other";
+/**
+ * One independently analysed set of loads, e.g. dead, superimposed dead or live. The loads
+ * themselves are listed in `FeaModel.nodalLoads` and `FeaModel.memberLoads`, each tagged
+ * with its `loadCase`.
+ */
+export interface LoadCase {
+    id: string;
+    name?: string;
+    type?: LoadCaseType;
+    /**
+     * Self-weight multiplier (1 = full self-weight). Applies `selfWeight · unitWeight · A` per unit
+     * length of every member and `selfWeight · unitWeight · thickness` (times `modifiers.weight`)
+     * per unit area of every shell, along global −Z. Default 0.
+     */
+    selfWeight?: number;
+}
+/** One term of a load combination: a factor times a load case or another combination. */
+export type CombinationTerm = {
+    case: string;
+    factor: number;
+} | {
+    combination: string;
+    factor: number;
+};
+/** A linear combination (sum of factored terms) of load cases and other combinations. */
+export interface LoadCombination {
+    id: string;
+    name?: string;
+    terms: CombinationTerm[];
+}
+export interface FeaModel {
+    nodes: FeaNode[];
+    /** Frame members; omit for a model of shells only, e.g. a mat foundation. */
+    members?: Member[];
+    restraints: Restraint[];
+    /** Fixed DOFs of every node along straight lines, generated mesh nodes included. */
+    lineRestraints?: LineRestraint[];
+    loadCases: LoadCase[];
+    /** Nodal loads of every load case, each tagged with its `loadCase`. */
+    nodalLoads?: NodalLoad[];
+    /** Member loads of every load case, each tagged with its `loadCase`. */
+    memberLoads?: MemberLoad[];
+    /** Null areas that distribute `areaLoads` to the members along their edges. */
+    areas?: NullArea[];
+    /** Shell areas: four-node flat shell elements with membrane and/or plate stiffness. */
+    shells?: ShellArea[];
+    /** Area loads of every load case, each tagged with its `loadCase`. */
+    areaLoads?: AreaLoad[];
+    combinations?: LoadCombination[];
+}

package/dist/fea/analysis/types/model.type.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=model.type.js.map

package/dist/fea/analysis/types/model.type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.type.js","sourceRoot":"","sources":["../../../../src/fea/analysis/types/model.type.ts"],"names":[],"mappings":""}

package/dist/fea/analysis/types/results.type.d.ts

@@ -0,0 +1,113 @@
+import type { Warnings } from "../../../core/types/output-message.type";
+import type { MemberDiagram, MemberEndForces, MemberReleaseDeformations, StationComponent } from "../../frame/types/results.type";
+import type { FeaId } from "../../shared/types/model.type";
+import type { FeaMesh, ShellElementForces, ShellForceComponent } from "../../shell/types/results.type";
+import type { LoadCaseType } from "./model.type";
+export interface NodalDisplacement {
+    nodeId: FeaId;
+    ux: number;
+    uy: number;
+    uz: number;
+    rx: number;
+    ry: number;
+    rz: number;
+}
+export interface NodalReaction {
+    nodeId: FeaId;
+    fx: number;
+    fy: number;
+    fz: number;
+    mx: number;
+    my: number;
+    mz: number;
+}
+/** A rotation direction at a node held by `analyze` because no member resists it. */
+export interface AutoRestrainedDof {
+    nodeId: FeaId;
+    /** Unit vector of the held rotation axis, global X, Y, Z. */
+    axis: [number, number, number];
+    /** The global rotation DOF when `axis` is a global axis. */
+    dof?: "rx" | "ry" | "rz";
+}
+/** Max or min of a result across combinations, with the combination that produces it. */
+export interface GoverningValue {
+    value: number;
+    combinationId: string;
+}
+export interface GoverningExtremeValue extends GoverningValue {
+    x: number;
+}
+export type Bound<T> = {
+    max: T;
+    min: T;
+};
+/** Results of one load case or one load combination. */
+export interface FeaCaseResult {
+    id: string;
+    kind: "case" | "combination";
+    name?: string;
+    type?: LoadCaseType;
+    nodalDisplacements: NodalDisplacement[];
+    reactions: NodalReaction[];
+    memberEndForces: MemberEndForces[];
+    /** One entry per member with any released or spring end DOF, in model order. */
+    releaseDeformations: MemberReleaseDeformations[];
+    memberDiagrams: MemberDiagram[];
+    /** One entry per shell element, area by area in model order (see `FeaResult.mesh`). */
+    shellForces: ShellElementForces[];
+    equilibriumResidual: {
+        force: number;
+        moment: number;
+    };
+    warnings: Warnings;
+}
+/** Max/min of every result across a set of combinations, with the governing combination. */
+export interface FeaEnvelope {
+    combinationIds: string[];
+    nodalDisplacements: ({
+        nodeId: FeaId;
+    } & Record<"ux" | "uy" | "uz" | "rx" | "ry" | "rz", Bound<GoverningValue>>)[];
+    reactions: ({
+        nodeId: FeaId;
+    } & Record<"fx" | "fy" | "fz" | "mx" | "my" | "mz", Bound<GoverningValue>>)[];
+    members: {
+        memberId: FeaId;
+        extremes: Record<StationComponent, Bound<GoverningExtremeValue>>;
+    }[];
+    shells: {
+        shellId: FeaId;
+        corners: ({
+            nodeId: FeaId;
+        } & Record<ShellForceComponent, Bound<GoverningValue>>)[];
+    }[];
+}
+export interface FeaResult {
+    cases: Record<string, FeaCaseResult>;
+    combinations: Record<string, FeaCaseResult>;
+    /** Envelope over all combinations; absent when the model has none. */
+    envelope?: FeaEnvelope;
+    /** The shell mesh; absent when the model has no shells. */
+    mesh?: FeaMesh;
+    calculationDetails: {
+        nodeCount: number;
+        memberCount: number;
+        shellCount: number;
+        dofCount: number;
+        freeDofCount: number;
+        profileSize: number;
+        loadCaseCount: number;
+        combinationCount: number;
+        /** Joint rotations held because every member there releases them (e.g. truss joints). */
+        autoRestrainedDofs: AutoRestrainedDof[];
+    };
+    units: {
+        force: "kN";
+        moment: "kN·m";
+        length: "mm";
+        rotation: "rad";
+        forcePerLength: "kN/m";
+        momentPerLength: "kN·m/m";
+        stress: "MPa";
+    };
+    warnings: Warnings;
+}

package/dist/fea/analysis/types/results.type.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=results.type.js.map

package/dist/fea/analysis/types/results.type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"results.type.js","sourceRoot":"","sources":["../../../../src/fea/analysis/types/results.type.ts"],"names":[],"mappings":""}

package/dist/fea/analysis/validation/validate-model.d.ts

@@ -0,0 +1,12 @@
+import { type FeaModelIssue } from "../../../core/errors/fea.error";
+import type { FeaModel } from "../types/model.type";
+/**
+ * Checks a model without analysing it and returns every problem found, each with the
+ * node, member, load case, combination and field it concerns. An empty array means the
+ * model can be analysed, apart from an unstable structure (304) and a translation that nothing
+ * resists at a node connected only to shells (328), which only assembling the stiffness detects.
+ *
+ * @param model - The model to check
+ * @returns Every problem found (codes 301–303, 305–317 and 326–327, 329), in model order
+ */
+export declare const validateModel: (model: FeaModel) => FeaModelIssue[];

package/dist/fea/analysis/validation/validate-model.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateModel = void 0;
+const fea_error_1 = require("../../../core/errors/fea.error");
+const validate_members_1 = require("../../frame/validation/validate-members");
+const validate_null_areas_1 = require("../../frame/validation/validate-null-areas");
+const issues_1 = require("../../shared/validation/issues");
+const validate_shells_1 = require("../../shell/validation/validate-shells");
+const combinations_1 = require("../solver/combinations");
+const DOF_KEYS = ["ux", "uy", "uz", "rx", "ry", "rz"];
+const NODAL_LOAD_KEYS = ["fx", "fy", "fz", "mx", "my", "mz"];
+const GLOBAL_DIRECTIONS = new Set(["X", "Y", "Z"]);
+const AREA_DIRECTIONS = {
+    "3": "normal",
+    X: [1, 0, 0],
+    Y: [0, 1, 0],
+    Z: [0, 0, 1],
+};
+const LOAD_CASE_TYPES = new Set([
+    "dead",
+    "superDead",
+    "live",
+    "roofLive",
+    "snow",
+    "wind",
+    "seismic",
+    "other",
+]);
+/**
+ * Checks a model without analysing it and returns every problem found, each with the
+ * node, member, load case, combination and field it concerns. An empty array means the
+ * model can be analysed, apart from an unstable structure (304) and a translation that nothing
+ * resists at a node connected only to shells (328), which only assembling the stiffness detects.
+ *
+ * @param model - The model to check
+ * @returns Every problem found (codes 301–303, 305–317 and 326–327, 329), in model order
+ */
+const validateModel = (model) => {
+    const issues = [];
+    const add = (std, details = {}) => issues.push((0, issues_1.modelIssue)(std, details));
+    const nodes = Array.isArray(model.nodes) ? model.nodes : [];
+    const members = Array.isArray(model.members) ? model.members : [];
+    const restraints = Array.isArray(model.restraints) ? model.restraints : [];
+    const loadCases = Array.isArray(model.loadCases) ? model.loadCases : [];
+    const combinations = Array.isArray(model.combinations) ? model.combinations : [];
+    const nodalLoads = Array.isArray(model.nodalLoads) ? model.nodalLoads : [];
+    const memberLoads = Array.isArray(model.memberLoads) ? model.memberLoads : [];
+    const areas = Array.isArray(model.areas) ? model.areas : [];
+    const shells = Array.isArray(model.shells) ? model.shells : [];
+    const lineRestraints = Array.isArray(model.lineRestraints) ? model.lineRestraints : [];
+    const areaLoads = Array.isArray(model.areaLoads) ? model.areaLoads : [];
+    // ---- Ids -------------------------------------------------------------------------
+    const duplicates = (ids) => ids.filter((id, i) => ids.indexOf(id) !== i);
+    for (const nodeId of new Set(duplicates(nodes.map((n) => n.id)))) {
+        add(fea_error_1.FeaErrors.DUPLICATE_ID, { nodeId, field: "id" });
+    }
+    for (const memberId of new Set(duplicates(members.map((m) => m.id)))) {
+        add(fea_error_1.FeaErrors.DUPLICATE_ID, { memberId, field: "id" });
+    }
+    for (const areaId of new Set(duplicates(areas.map((a) => a.id)))) {
+        add(fea_error_1.FeaErrors.DUPLICATE_ID, { areaId, field: "id" });
+    }
+    // shells share the area id namespace: a duplicate within shells or with a null area
+    const nullAreaIds = new Set(areas.map((a) => a.id));
+    for (const shellId of new Set([
+        ...duplicates(shells.map((sh) => sh.id)),
+        ...shells.map((sh) => sh.id).filter((id) => nullAreaIds.has(id)),
+    ])) {
+        add(fea_error_1.FeaErrors.DUPLICATE_ID, { shellId, field: "id" });
+    }
+    for (const nodeId of new Set(duplicates(restraints.map((r) => r.nodeId)))) {
+        add(fea_error_1.FeaErrors.DUPLICATE_ID, { nodeId, field: "restraints" });
+    }
+    const caseIds = new Set(loadCases.map((c) => c.id));
+    const combinationIds = new Set(combinations.map((c) => c.id));
+    for (const id of new Set(duplicates([...loadCases.map((c) => c.id), ...combinations.map((c) => c.id)]))) {
+        add(fea_error_1.FeaErrors.DUPLICATE_ID, combinationIds.has(id) && !caseIds.has(id) ? { combinationId: id } : { loadCaseId: id });
+    }
+    // ---- Nodes -----------------------------------------------------------------------
+    const nodeById = new Map();
+    const validNode = new Set();
+    for (const node of nodes) {
+        nodeById.set(node.id, node);
+        let ok = true;
+        for (const field of ["x", "y", "z"]) {
+            if (!(0, issues_1.isFiniteNumber)(node[field])) {
+                add(fea_error_1.FeaErrors.INVALID_INPUT_VALUE, { nodeId: node.id, field });
+                ok = false;
+            }
+        }
+        if (ok)
+            validNode.add(node.id);
+    }
+    // ---- Members ---------------------------------------------------------------------
+    const checkedMembers = (0, validate_members_1.validateMembers)(members, nodeById, validNode);
+    issues.push(...checkedMembers.issues);
+    const { memberLength } = checkedMembers;
+    // ---- Restraints ------------------------------------------------------------------
+    let anyRestrained = false;
+    for (const restraint of restraints) {
+        if (!nodeById.has(restraint.nodeId)) {
+            add(fea_error_1.FeaErrors.UNKNOWN_NODE_REFERENCE, { nodeId: restraint.nodeId, field: "restraints" });
+        }
+        for (const field of DOF_KEYS) {
+            const v = restraint[field];
+            if (v === undefined || v === false)
+                continue;
+            if (v === true) {
+                anyRestrained = true;
+            }
+            else if ((0, issues_1.isFiniteNumber)(v) && v >= 0) {
+                if (v > 0)
+                    anyRestrained = true;
+            }
+            else {
+                add(fea_error_1.FeaErrors.INVALID_INPUT_VALUE, { nodeId: restraint.nodeId, field });
+            }
+        }
+    }
+    for (const line of lineRestraints) {
+        const ids = Array.isArray(line.nodeIds) ? line.nodeIds : [];
+        const at = { nodeId: ids[0], field: "lineRestraints.nodeIds" };
+        if (ids.length !== 2 || ids[0] === ids[1])
+            add(fea_error_1.FeaErrors.INVALID_INPUT_VALUE, at);
+        else if (ids.some((id) => !nodeById.has(id)))
+            add(fea_error_1.FeaErrors.UNKNOWN_NODE_REFERENCE, at);
+        for (const field of DOF_KEYS) {
+            const v = line[field];
+            if (v === undefined || v === false)
+                continue;
+            if (v === true)
+                anyRestrained = true;
+            else
+                add(fea_error_1.FeaErrors.INVALID_INPUT_VALUE, { nodeId: ids[0], field: `lineRestraints.${field}` });
+        }
+    }
+    if (!anyRestrained)
+        add(fea_error_1.FeaErrors.NO_RESTRAINTS);
+    // ---- Load cases ------------------------------------------------------------------
+    if (loadCases.length === 0)
+        add(fea_error_1.FeaErrors.NO_LOAD_CASES);
+    for (const loadCase of loadCases) {
+        const at = { loadCaseId: loadCase.id };
+        if (loadCase.type !== undefined && !LOAD_CASE_TYPES.has(loadCase.type)) {
+            add(fea_error_1.FeaErrors.INVALID_INPUT_VALUE, { ...at, field: "type" });
+        }
+        if (loadCase.selfWeight === undefined)
+            continue;
+        if (!(0, issues_1.isFiniteNumber)(loadCase.selfWeight)) {
+            add(fea_error_1.FeaErrors.INVALID_LOAD_FACTOR, { ...at, field: "selfWeight" });
+            continue;
+        }
+        if (loadCase.selfWeight !== 0) {
+            for (const member of members) {
+                if (member.section?.unitWeight === undefined) {
+                    add(fea_error_1.FeaErrors.MISSING_UNIT_WEIGHT, { ...at, memberId: member.id, field: "unitWeight" });
+                }
+            }
+            for (const shell of shells) {
+                if (shell.section?.unitWeight === undefined) {
+                    add(fea_error_1.FeaErrors.MISSING_UNIT_WEIGHT, {
+                        ...at,
+                        shellId: shell.id,
+                        field: "section.unitWeight",
+                    });
+                }
+            }
+        }
+    }
+    // ---- Loads -----------------------------------------------------------------------
+    for (const load of nodalLoads) {
+        const at = { loadCaseId: load.loadCase, nodeId: load.nodeId };
+        if (!caseIds.has(load.loadCase))
+            add(fea_error_1.FeaErrors.UNKNOWN_LOAD_CASE, { ...at, field: "loadCase" });
+        if (!nodeById.has(load.nodeId))
+            add(fea_error_1.FeaErrors.UNKNOWN_NODE_REFERENCE, { ...at, field: "nodeId" });
+        for (const field of NODAL_LOAD_KEYS) {
+            if (load[field] !== undefined && !(0, issues_1.isFiniteNumber)(load[field])) {
+                add(fea_error_1.FeaErrors.INVALID_INPUT_VALUE, { ...at, field });
+            }
+        }
+    }
+    issues.push(...(0, validate_members_1.validateMemberLoads)(memberLoads, members, memberLength, caseIds));
+    // ---- Areas -----------------------------------------------------------------------
+    const checkedAreas = (0, validate_null_areas_1.validateNullAreas)(areas, members, memberLength, nodeById, validNode);
+    issues.push(...checkedAreas.issues);
+    const { areaInfo } = checkedAreas;
+    // ---- Shells ----------------------------------------------------------------------
+    issues.push(...(0, validate_shells_1.validateShells)(shells, nodeById, validNode));
+    // the mesh, once every shell and its mesh settings are valid
+    const shellProblem = issues.some((i) => i.details.shellId !== undefined);
+    const nodeProblem = nodes.length !== validNode.size;
+    if (shells.length > 0 && !shellProblem && !nodeProblem) {
+        issues.push(...(0, validate_shells_1.validateShellMesh)(nodes, shells));
+    }
+    const areaIds = new Set([...areas.map((a) => a.id), ...shells.map((sh) => sh.id)]);
+    for (const load of areaLoads) {
+        const at = { loadCaseId: load.loadCase, areaId: load.areaId };
+        if (!caseIds.has(load.loadCase))
+            add(fea_error_1.FeaErrors.UNKNOWN_LOAD_CASE, { ...at, field: "loadCase" });
+        if (!areaIds.has(load.areaId)) {
+            add(fea_error_1.FeaErrors.UNKNOWN_NODE_REFERENCE, { ...at, field: "areaId" });
+        }
+        const direction = Object.prototype.hasOwnProperty.call(AREA_DIRECTIONS, load.direction)
+            ? AREA_DIRECTIONS[load.direction]
+            : undefined;
+        if (!direction)
+            add(fea_error_1.FeaErrors.INVALID_INPUT_VALUE, { ...at, field: "direction" });
+        if (!(0, issues_1.isFiniteNumber)(load.q))
+            add(fea_error_1.FeaErrors.INVALID_INPUT_VALUE, { ...at, field: "q" });
+        if ((load.projected !== undefined && typeof load.projected !== "boolean") ||
+            (load.projected === true && !GLOBAL_DIRECTIONS.has(load.direction))) {
+            add(fea_error_1.FeaErrors.INVALID_INPUT_VALUE, { ...at, field: "projected" });
+        }
+        const info = areaInfo.get(load.areaId);
+        if (direction &&
+            direction !== "normal" &&
+            info &&
+            (0, validate_null_areas_1.loadsAlongCantileverSupport)(info, direction)) {
+            add(fea_error_1.FeaErrors.INVALID_AREA_DISTRIBUTION, { ...at, field: "direction" });
+        }
+    }
+    // ---- Combinations ----------------------------------------------------------------
+    let referencesOk = true;
+    for (const combination of combinations) {
+        const at = { combinationId: combination.id };
+        if (!Array.isArray(combination.terms) || combination.terms.length === 0) {
+            add(fea_error_1.FeaErrors.INVALID_LOAD_FACTOR, { ...at, field: "terms" });
+            referencesOk = false;
+            continue;
+        }
+        for (const term of combination.terms) {
+            if (!(0, issues_1.isFiniteNumber)(term.factor)) {
+                add(fea_error_1.FeaErrors.INVALID_LOAD_FACTOR, { ...at, field: "factor" });
+                referencesOk = false;
+            }
+            const caseRef = "case" in term ? term.case : undefined;
+            const comboRef = "combination" in term ? term.combination : undefined;
+            if ((caseRef === undefined) === (comboRef === undefined)) {
+                add(fea_error_1.FeaErrors.UNKNOWN_LOAD_CASE, { ...at, field: "terms" });
+                referencesOk = false;
+            }
+            else if (caseRef !== undefined && !caseIds.has(caseRef)) {
+                add(fea_error_1.FeaErrors.UNKNOWN_LOAD_CASE, { ...at, loadCaseId: caseRef, field: "case" });
+                referencesOk = false;
+            }
+            else if (comboRef !== undefined && !combinationIds.has(comboRef)) {
+                add(fea_error_1.FeaErrors.UNKNOWN_LOAD_CASE, { ...at, field: "combination" });
+                referencesOk = false;
+            }
+        }
+    }
+    if (referencesOk && combinations.length > 0) {
+        try {
+            (0, combinations_1.resolveCombinations)(combinations, caseIds);
+        }
+        catch (e) {
+            if (e instanceof fea_error_1.FeaError)
+                issues.push({ ...(0, issues_1.modelIssue)(e, e.details) });
+            else
+                throw e;
+        }
+    }
+    return issues;
+};
+exports.validateModel = validateModel;
+//# sourceMappingURL=validate-model.js.map