Lettura dei risultati

Dopo solve(), i risultati si leggono dai nodi e dalle aste, per un caso di carico dato. Ogni esempio di questa pagina legge lo stesso modello, una trave semplicemente appoggiata di 6 m, un IPE 200 indeformabile a taglio, con 20 kN a 2 m da A:

results.ts
import { DofID, LinearStaticSolver } from '@edubeam/fem'

const solver = new LinearStaticSolver()
const { domain } = solver
domain.createMaterial(1, { e: 210e9, g: 81e9 })
domain.createCrossSection(1, { a: 28.5e-4, iy: 1943e-8, k: 1e32 }) // indeformabile a taglio

const A = domain.createNode('A', [0, 0, 0], [DofID.Dx, DofID.Dz])
const B = domain.createNode('B', [6, 0, 0], [DofID.Dz])
const beam = domain.createBeam2D(1, ['A', 'B'], 1, 1)
const lc = solver.loadCases[0]
lc.createBeamConcentratedLoad(1, [0, 20e3, 0, 2], true)
solver.solve()
20 kN a 2 m su una campata di 6 m13,33−6,667−6,66720 kN13,336,667AB
20 kN a 2 m su una campata di 6 mApri in EduBeam

Cosa leggere e dove

RisultatoChiamataRestituisce
Reazioninode.getReactions(lc){ dofs, values }: N, N·m
Spostamentinode.getUnknowns(lc, dofs)m, rad
N, V o M in un puntobeam.computeBendingMomentAt(lc, x)un numero: N, N·m
N, V o M lungo un’astabeam.computeBendingMoment(lc, n){ x, M }, n + 1 punti
Deformatabeam.computeLocalDefl(lc, n){ u, w }, n + 1 punti, m
Forze di estremitàbeam.computeEndForces(lc)una matrice mathjs di 6 valori

Per N e V i metodi sono computeNormalForceAt e computeShearForceAt, computeNormalForce e computeShearForce, che restituiscono { x, N } e { x, V }. I segni sono spiegati in Unità e segni.

Reazioni

getReactions dà una reazione per ogni GdL bloccato dal vincolo: dofs li elenca, nell’ordine in cui sono stati passati a createNode, e values contiene le reazioni nello stesso ordine. values è una matrice mathjs quando le reazioni sono più di una e un semplice array quando ce n’è una sola, quindi una piccola funzione di supporto lo trasforma in array in entrambi i casi:

TypeScript
/** Trasforma una Matrix di mathjs, un array o un numero in un semplice array. */
const list = (v: unknown): number[] =>
  typeof v === 'number'
    ? [v]
    : Array.isArray(v)
      ? v
      : (v as { toArray(): number[] }).toArray()

A.getReactions(lc).dofs // [0, 2]: DofID.Dx, DofID.Dz
list(A.getReactions(lc).values) // [0, -13333.3]
list(B.getReactions(lc).values) // [-6666.7]

Per prendere una singola reazione indipendentemente dall’ordine, cerca il suo GdL: list(values)[dofs.indexOf(DofID.Dz)], come fa l’esempio della trave continua.

Una reazione è la forza che il vincolo esercita sulla struttura: −13 333 N lungo z sono 13,3 kN verso l’alto, . Su un nodo con assi ruotati, le reazioni sono in quegli assi; getReactions(lc, true) le riporta negli assi globali e restituisce tutti e tre i GdL, con 0 dove nulla è bloccato. Un nodo senza vincolo dà { dofs: [], values: [] }.

Spostamenti

getUnknowns legge qualsiasi GdL di un nodo, vincolato o no:

TypeScript
list(A.getUnknowns(lc, [DofID.Dx, DofID.Dz, DofID.Ry])) // [0, 0, -0.0108924]

A ruota in senso orario di 0,010892 rad, . Se chiedi un solo GdL, getUnknowns restituisce un semplice numero, anche se TypeScript dichiara una matrice: list gestisce anche questo caso.

Forze interne lungo un’asta

I metodi …At danno il valore a x metri dal primo nodo dell’asta:

TypeScript
beam.computeShearForceAt(lc, 1) // 13333.3 N
beam.computeShearForceAt(lc, 2) // -6666.7 N: nel punto del carico, il valore subito dopo
beam.computeBendingMomentAt(lc, 2) // 26666.7 N·m: R_A · 2

Dove un carico concentrato produce un salto, il valore esattamente nel punto del carico è quello che si ha dopo il carico. Per leggere il valore che precede il salto, chiedilo appena prima, ad esempio a x - 1e-9.

I metodi che restituiscono array campionano un’asta in n + 1 punti equidistanti, estremi compresi:

TypeScript
beam.computeBendingMoment(lc, 3)
// { x: [0, 2, 4, 6], M: [0, 26666.7, 13333.3, 0] }, a meno degli arrotondamenti

Aspettati errori di arrotondamento come -3.6e-12 dove il valore esatto è 0: formatta i numeri con toFixed prima di stamparli. Per il valore massimo lungo un’asta prendi il massimo di un campionamento fitto, ad esempio computeBendingMoment(lc, 500), come nell’esempio della trave continua. Con carichi distribuiti M è un polinomio, quindi il suo estremo esatto si trova dove V si annulla; @edubeam/plot lo trova esattamente.

Deformata

TypeScript
beam.computeLocalDefl(lc, 3)
// { u: [0, 0, 0, 0], w: [0, 0.0174279, 0.0152494, 0] }

computeLocalDefl dà gli spostamenti lungo l’asta e trasversali, u e w, nei suoi assi locali; computeGlobalDefl dà gli stessi punti in x e z globali. La freccia sotto il carico, 17,43 mm, è . La forma tra i nodi è esatta, non interpolata dai valori agli estremi. Per disegnarla, vedi Disegnare i risultati.

Forze di estremità

TypeScript
beam.computeEndForces(lc).toArray()
// [0, -13333.3, 0, 0, -6666.7, 0]: X12, Z12, M12, X21, Z21, M21

Le forze che i due nodi esercitano sull’asta, nei suoi assi locali: sono i numeri della tabella Risultati degli elementi dell’app, spiegati in Forze di estremità.

Risultati da verificare

Ogni valore qui sopra coincide con la sua formula in forma chiusa. La pagina Verificare i risultati a mano svolge molti altri casi da libro di testo, risolti da questo stesso solutore nel tuo browser.