Zeichenmodell

Alles, was @edubeam/plot zeichnet, stammt aus einem PlotModel: einfachen Daten, die modelFromSolver aus einem berechneten Modell von @edubeam/fem ausliest. Es enthält die Geometrie, die Lager, die Lasten, die Auflagerreaktionen und die Ergebnisse jedes Stabs als exakte Polynome. Es lässt sich als JSON serialisieren, kann also beim Build erzeugt und statt des Solvers ausgeliefert werden, und es ist der einfachste Weg, exakte Werte und Extremwerte eines berechneten Tragwerks abzulesen.

TypeScript
import { modelFromSolver } from '@edubeam/plot'

const model = modelFromSolver(solver) // oder modelFromSolver(solver, { loadCase: 1 })

results ist nur vorhanden, wenn der Lastfall berechnet ist. Ohne Ergebnisse zeichnen die Komponenten nur das Modell, und mit reactionLabels: 'names' trotzdem die unbekannten Auflagerreaktionen; ein nicht berechnetes Modell kann also ein Übungsblatt sein.

Das Format

Alles ist in SI-Einheiten (m, N, N·m, N/m, K, rad) und in den Achsen des Solvers angegeben: x nach rechts, z nach unten, Verdrehungen auf dem Bildschirm gegen den Uhrzeigersinn positiv.

TypeScript
interface PlotModel {
  readonly nodes: readonly PlotNode[]
  readonly members: readonly PlotMember[]
  readonly loads: readonly PlotLoad[]
  readonly results?: PlotResults // nur für einen berechneten Lastfall
}

interface PlotNode {
  readonly id: string
  readonly x: number
  readonly z: number
  readonly fixity: { readonly dx: boolean; readonly dz: boolean; readonly ry: boolean } // gehaltene Freiheitsgrade
  readonly angle: number // Drehung der Achsen eines gedrehten Lagers, rad, auf dem Bildschirm im Uhrzeigersinn
}

interface PlotMember {
  readonly id: string
  readonly start: string // Knoten-IDs
  readonly end: string
  readonly hinges: readonly [boolean, boolean]
}

interface PlotResults {
  readonly members: Readonly<Record<string, MemberResults>> // nach Stab-ID
  readonly reactions: readonly PlotReaction[]
}

interface MemberResults {
  readonly N: Piecewise // Normalkraft, Zug positiv
  readonly V: Piecewise // Querkraft
  readonly M: Piecewise // Biegemoment, positiv bei Zug auf der Seite der lokalen +z-Achse
  readonly u: Piecewise // Verschiebung in lokaler x-Richtung
  readonly w: Piecewise // Verschiebung in lokaler z-Richtung
}

interface PlotReaction {
  readonly node: string
  readonly dof: 'dx' | 'dz' | 'ry'
  readonly value: number // Kraft auf das Tragwerk in Richtung der Knotenachse, N (N·m für ry)
}

Es gibt sieben Arten von Lasten, unterschieden durch kind:

kindFelderBedeutet
'nodalForce'node, fx, fzeine Kraft an einem Knoten, globale Komponenten, N
'nodalMoment'node, myein Moment an einem Knoten, N·m
'distributed'member, start, end, localeine linear veränderliche Streckenlast, { fx, fz } an jedem Ende, N/m; bei gleichen Werten eine Gleichlast
'pointForce'member, at, fx, fz, localeine Kraft at Meter vom Stabanfang
'pointMoment'member, at, myein Einzelmoment auf einem Stab
'temperature'member, uniform, gradientK: die Änderung im Schwerpunkt und unten minus oben
'prescribed'node, dx?, dz?, ry?eine Lagerverschiebung in den Knotenachsen, m und rad

local ist true, wenn die Komponenten in Richtung der lokalen x- und z-Achse des Stabs statt der globalen Achsen angegeben sind.

Stückweise Polynome

Das Ergebnis eines Stabs ist ein Piecewise: eine Liste von Abschnitten, jeder ein Polynom über einen Teil des Stabs. Ein neuer Abschnitt beginnt überall dort, wo eine Einzellast oder ein Einzelmoment einen Knick oder Sprung im Ergebnis erzeugt.

TypeScript
interface Piece {
  readonly x0: number // m vom Stabanfang
  readonly x1: number
  readonly c: readonly number[] // Wert = Σ c[k]·sᵏ, mit s = (x − x0)/(x1 − x0)
}
type Piecewise = readonly Piece[]

N, V und M sind höchstens kubisch, die Durchbiegung höchstens fünften Grades, sodass wenige Koeffizienten das Ergebnis des Solvers exakt wiedergeben. Die Querkraft eines Trägers von 6 m mit 20 kN bei 2 m besteht aus zwei konstanten Abschnitten:

JSON
[{ "x0": 0, "x1": 2, "c": [13333.33] }, { "x0": 2, "x1": 6, "c": [-6666.67] }]

Werte selbst ablesen

Die Funktionen, die die Verläufe zeichnen, lesen sie auch ab, exakt und ohne Abtasten:

TypeScript
import { extremes, innerBreaks, modelFromSolver, valueAt } from '@edubeam/plot'

// Einfeldträger 6 m, 20 kN bei 2 m von A, schubstarrer IPE 200
const model = modelFromSolver(solver)
const { V, M, w } = model.results!.members['1']

innerBreaks(V) // [2]: die Abschnitte treffen sich an der Last
valueAt(V, 2, 'left') // 13333.3 N, unmittelbar vor der Last
valueAt(V, 2, 'right') // -6666.7 N, unmittelbar danach
extremes(M) // max 26666.7 N·m bei x = 2
extremes(w) // max 0.018973 m bei x = 2.734

extremes gibt { max, min } zurück, jeweils { x, value, side }, oder null für eine leere Liste. Die größte Durchbiegung liegt nicht unter der Last, sondern bei m und beträgt mm, wie es die Formel für eine außermittige Last ergibt.

So findet der Aufgabengenerator die extremen Momente für sein Lösungsblatt. Den Rest listet die Seite Funktionen auf: Neigungen, Extremwerte innerhalb eines Abschnitts, Polynomgrade und Bézierkurven.

Als JSON ausliefern

JSON.stringify(model) genügt, und JSON.parse liefert ein Modell zurück, das genau so gezeichnet wird wie aus dem Solver. Ein Portalrahmen mit einer Streckenlast und einer Einzellast braucht weniger als 2 kB. Siehe Einbinden. Ein Modell lässt sich auch an structureSvg übergeben, das es als SVG-Datei schreibt.