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

package/dist/fea/{frame/area → analysis/solver}/distribute-area-loads.d.ts

@@ -1,18 +1,9 @@
 import type { Warnings } from "../../../core/types/output-message.type";
-import type { FrameModel, MemberLoad } from "../types/model.type";
-/**
- * Turns the area loads of a model into member loads, assuming the model is valid (as
- * `validateFrameModel` checks): each area's edge profiles are built once, then scaled for each
- * of its loads and split into global X, Y and Z trapezoidal loads (plus torques for a cantilever).
- * Everything is linear in `q`, so load-case superposition still holds.
- */
-export declare const areaMemberLoads: (model: FrameModel) => {
-    memberLoads: MemberLoad[];
-    warnings: Warnings;
-};
+import type { MemberLoad } from "../../frame/types/model.type";
+import type { FeaModel } from "../types/model.type";
 /**
  * The member loads that a model's null areas send to the members along their edges — what
- * `analyzeFrame` adds to `memberLoads` — so they can be checked or previewed.
+ * `analyze` adds to `memberLoads` — so they can be checked or previewed.
  *
  * Two-way areas send each point to the nearest edge (corner-bisector split); one-way areas
  * split strips parallel to their unsupported edges half to each end; cantilever areas send
@@ -21,11 +12,11 @@ export declare const areaMemberLoads: (model: FrameModel) => {
  * `projected` load is first converted, `q · |n · direction|`) and come out as trapezoidal loads
  * per member length in global X, Y and Z (and torques), each tagged with its load case.
  *
- * @param model - The frame model, validated first
+ * @param model - The model, validated first
  * @returns `memberLoads` and `warnings` (a one-way support edge parallel to the span)
- * @throws {FrameAnalysisError} 301–317 for an invalid model, with every problem in `issues`
+ * @throws {FeaError} 301–317 for an invalid model, with every problem in `issues`
  */
-export declare const distributeAreaLoads: (model: FrameModel) => {
+export declare const distributeAreaLoads: (model: FeaModel) => {
     memberLoads: MemberLoad[];
     warnings: Warnings;
 };

package/dist/fea/analysis/solver/distribute-area-loads.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.distributeAreaLoads = void 0;
+const area_member_loads_1 = require("../../frame/area/area-member-loads");
+const issues_1 = require("../../shared/validation/issues");
+const validate_model_1 = require("../validation/validate-model");
+/**
+ * The member loads that a model's null areas send to the members along their edges — what
+ * `analyze` adds to `memberLoads` — so they can be checked or previewed.
+ *
+ * Two-way areas send each point to the nearest edge (corner-bisector split); one-way areas
+ * split strips parallel to their unsupported edges half to each end; cantilever areas send
+ * `q · c` and a torque `q · c² / 2` per unit length to their support edge (c = depth). Edges
+ * split by intermediate nodes are cut at those nodes. Loads are per unit true area (a
+ * `projected` load is first converted, `q · |n · direction|`) and come out as trapezoidal loads
+ * per member length in global X, Y and Z (and torques), each tagged with its load case.
+ *
+ * @param model - The model, validated first
+ * @returns `memberLoads` and `warnings` (a one-way support edge parallel to the span)
+ * @throws {FeaError} 301–317 for an invalid model, with every problem in `issues`
+ */
+const distributeAreaLoads = (model) => {
+    const issues = (0, validate_model_1.validateModel)(model);
+    if (issues.length > 0)
+        (0, issues_1.throwIssues)(issues);
+    return (0, area_member_loads_1.areaMemberLoads)(model);
+};
+exports.distributeAreaLoads = distributeAreaLoads;
+//# sourceMappingURL=distribute-area-loads.js.map

package/dist/fea/analysis/solver/distribute-area-loads.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"distribute-area-loads.js","sourceRoot":"","sources":["../../../../src/fea/analysis/solver/distribute-area-loads.ts"],"names":[],"mappings":";;;AACA,6EAAwE;AAExE,8DAAgE;AAGhE,iEAA6D;AAE7D;;;;;;;;;;;;;;GAcG;AACI,MAAM,mBAAmB,GAAG,CACjC,KAAe,EACoC,EAAE;IACrD,MAAM,MAAM,GAAG,IAAA,8BAAa,EAAC,KAAK,CAAC,CAAC;IACpC,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC;QAAE,IAAA,oBAAW,EAAC,MAAM,CAAC,CAAC;IAC3C,OAAO,IAAA,mCAAe,EAAC,KAAK,CAAC,CAAC;AAChC,CAAC,CAAC;AANW,QAAA,mBAAmB,uBAM9B"}

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,123 @@
+import type { Warnings } from "../../../core/types/output-message.type";
+import type { MemberDiagram, MemberEndForces, MemberIntermediateNode, MemberNearMissNode, 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[];
+        /**
+         * Model nodes lying on a member between its ends that were connected to it (see
+         * `Member.connectIntermediateNodes`), member by member from its start.
+         */
+        intermediateNodes: MemberIntermediateNode[];
+        /**
+         * Model nodes close to a member but not on it, so not connected to it, each with a
+         * "Member connectivity" warning; same order.
+         */
+        nearMissNodes: MemberNearMissNode[];
+    };
+    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[];