बीम

कॉपी करके बदलने के लिए दो पूरे प्रोग्राम। दोनों अपरूपण-दृढ़ काट (k: 1e32) लेते हैं, इसलिए उनकी संख्याएँ ठीक Euler–Bernoulli सूत्रों वाली हैं। इन्हें node cantilever.ts (Node 22.18 या उसके बाद) से चलाएँ, ऐसे फ़ोल्डर में जो इंस्टॉल करना के अनुसार तैयार किया गया हो।

कैंटिलीवर

4 m लंबा, A पर फिक्स्ड, मुक्त सिरे पर 18 kN नीचे की ओर:

cantilever.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 })

domain.createNode('A', [0, 0, 0], [DofID.Dx, DofID.Dz, DofID.Ry]) // फिक्स्ड
const tip = domain.createNode('B', [4, 0, 0]) // मुक्त
const beam = domain.createBeam2D(1, ['A', 'B'], 1, 1)

const lc = solver.loadCases[0]
lc.createNodalLoad('B', { [DofID.Dz]: 18e3 }) // मुक्त सिरे पर 18 kN नीचे की ओर
solver.solve()

console.log(beam.computeBendingMomentAt(lc, 0)) // फिक्स्ड सिरे पर, N·m
console.log(tip.getUnknowns(lc, [DofID.Dz])) // मुक्त सिरे का विक्षेप, m
Output
-72000
0.09411072715241528

kNm, होगिंग (ऊपरी तंतुओं में तनाव), और मुक्त सिरे का विक्षेप mm है, जहाँ MNm²। यही कैंटिलीवर EduBeam ऐप के उदाहरणों में भी है।

सतत बीम

तीन सपोर्टों पर 5 m के दो स्पैन, दोनों पर 10 kN/m। प्रतिक्रियाएँ, बीच वाले सपोर्ट के ऊपर आघूर्ण और स्पैन का सबसे बड़ा आघूर्ण:

continuous.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 })

domain.createNode('A', [0, 0, 0], [DofID.Dx, DofID.Dz])
domain.createNode('B', [5, 0, 0], [DofID.Dz])
domain.createNode('C', [10, 0, 0], [DofID.Dz])
const span1 = domain.createBeam2D(1, ['A', 'B'], 1, 1)
domain.createBeam2D(2, ['B', 'C'], 1, 1)

const lc = solver.loadCases[0]
for (const span of [1, 2]) {
  lc.createBeamElementUniformEdgeLoad(span, [0, 10e3], true)
}
solver.solve()

// getReactions mathjs Matrix या array देता है: उसे array बना लें
const list = (v: unknown): number[] =>
  Array.isArray(v) ? v : (v as { toArray(): number[] }).toArray()

for (const label of ['A', 'B', 'C']) {
  const { dofs, values } = domain.getNode(label).getReactions(lc)
  const rz = list(values)[dofs.indexOf(DofID.Dz)]
  console.log(`R${label} = ${(-rz / 1e3).toFixed(2)} kN up`)
}
const mB = span1.computeBendingMomentAt(lc, 5)
console.log(`MB = ${(mB / 1e3).toFixed(2)} kNm`)

// स्पैन 1 में सबसे बड़ा सैगिंग आघूर्ण, उसके अनुदिश 501 बिंदुओं से
const { x, M } = span1.computeBendingMoment(lc, 500)
const i = M.indexOf(Math.max(...M))
console.log(`max M = ${(M[i] / 1e3).toFixed(2)} kNm at x = ${x[i]} m`)
Output
RA = 18.75 kN up
RB = 62.50 kN up
RC = 18.75 kN up
MB = -31.25 kNm
max M = 17.58 kNm at x = 1.87 m

दो बराबर स्पैनों के पाठ्यपुस्तक वाले मान: , , , और स्पैन का सबसे बड़ा आघूर्ण kNm, m पर। 501 बिंदुओं वाली गणना इसे ग्रिड बिंदु 1.87 m पर पाती है, वास्तविक मान से 0.0002 kNm के भीतर।

10 kN/m भार वाले 5 m के दो स्पैन−31.2517.5817.58q = 10 kN/m18.7562.518.75ABC
10 kN/m भार वाले 5 m के दो स्पैनEduBeam में खोलें

चित्र IPE 200 के बजाय ऐप के उदाहरण वाला काट लेता है। पूरे बीम में एक ही काट हो, तो सतत बीम के आंतरिक बल उसकी कठोरता पर निर्भर नहीं करते, इसलिए आरेखों पर वही संख्याएँ आती हैं; केवल विक्षेप अलग होता है।

इसे बदलें

  • असमान स्पैन या भार: C के निर्देशांक या भारों की सूची बदलें। केवल एक स्पैन पर भार देने से जानी-पहचानी पैटर्न लोडिंग (pattern loading) बनती है।
  • तीन स्पैन: एक नोड D और एक सदस्य ['C', 'D'] जोड़ें।
  • फिक्स्ड सिरा: A को [DofID.Dx, DofID.Dz, DofID.Ry] दें।
  • वास्तविक अपरूपण विरूपण: आयताकार काट के लिए k: 5 / 6, या अपने काट का अपरूपण संशोधन गुणांक।
  • इसका चित्र: सॉल्वर @edubeam/plot को सौंप दें।

सतत बीम ट्यूटोरियल EduBeam ऐप में ऐसा ही बीम बनाता है, और परिणामों की हाथ से जाँच वाले पृष्ठ पर पाठ्यपुस्तक के और उदाहरण उनके सूत्रों के साथ हैं।