नोडल और सदस्य भार

भार किसी लोड केस के होते हैं। सॉल्वर एक लोड केस के साथ शुरू होता है, solver.loadCases[0], और उस पर हर create… method एक भार जोड़कर उसे लौटाता है। कई लोड केस और उनके संयोजनों के लिए देखें लोड केस।

मान N, N/m और N·m में होते हैं और अक्षों का पालन करते हैं: +z नीचे की ओर है, धनात्मक आघूर्ण वामावर्त है।

हर तरह के भार वाला बीम

पिन और रोलर सपोर्ट पर 8 m लंबा बीम, जिस पर 4 से 10 kN/m तक बढ़ता रेखीय भार, 20 kN का बिंदु भार, 10 kNm का युग्म (couple) और रोलर पर एक क्षैतिज बल है:

loads.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', [8, 0, 0], [DofID.Dz]) // रोलर
domain.createBeam2D(1, ['A', 'B'], 1, 1)

const lc = solver.loadCases[0]
// A पर 4 kN/m से B पर 10 kN/m तक बढ़ता, नीचे की ओर
lc.createBeamElementTrapezoidalEdgeLoad(1, [0, 4e3], [0, 10e3], false)
// [fx, fz, my, a]: 20 kN नीचे की ओर, A से 2 m पर
lc.createBeamConcentratedLoad(1, [0, 20e3, 0, 2], false)
// 10 kNm का वामावर्त युग्म, A से 6 m पर
lc.createBeamConcentratedLoad(1, [0, 0, 10e3, 6], false)
// B पर 5 kN दाईं ओर
lc.createNodalLoad('B', { [DofID.Dx]: 5e3 })
solver.solve()

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

console.log(list(domain.getNode('A').getReactions(lc).values))
console.log(list(domain.getNode('B').getReactions(lc).values))
Output
[ -5000, -40250 ]
[ -35750 ]

हाथ से: रेखीय भार 56 kN है और A से 4.571 m पर लगता है, इसलिए A के परितः आघूर्ण लेने पर , kN ऊपर, और kN ऊपर। पिन 5 kN के बल को भी थामता है, जिससे पूरे बीम में 5 kN का तनाव आता है।

वही भार। चित्र युग्म को 6 m पर एक नोड C पर रखता है, जिससे परिणाम वही रहते हैं।62.571.581.2210 kNm5 kN4 kN/m8.5 kN/m10 kN/m20 kN540.2535.75ACB
वही भार। चित्र युग्म को 6 m पर एक नोड C पर रखता है, जिससे परिणाम वही रहते हैं।EduBeam में खोलें

नोडल भार

TypeScript
lc.createNodalLoad(node, { [DofID.Dx]: fx, [DofID.Dz]: fz, [DofID.Ry]: my }, lcs)

केवल वे घटक दें जिनकी आपको ज़रूरत है। मान वैश्विक अक्षों में होते हैं, या lcs को true करने पर नोड के अपने अक्षों में, यदि नोड updateLcs से घुमाया गया है। सपोर्ट जिस DOF को रोकता है, उस पर लगा बल सीधे प्रतिक्रिया में चला जाता है और कुछ भी मोड़ता नहीं।

सदस्य भार

Methodमानभार
createBeamElementUniformEdgeLoad(el, [fx, fz], lcs)N/mपूरे सदस्य पर समान
createBeamElementTrapezoidalEdgeLoad(el, [fx1, fz1], [fx2, fz2], lcs)N/mरैखिक, पहले नोड से दूसरे तक
createBeamConcentratedLoad(el, [fx, fz, my, a], lcs)N, N·m, mएक बल और एक युग्म, पहले नोड से a मीटर पर

रेखीय भार हमेशा पूरे सदस्य पर लगते हैं। स्पैन के किसी हिस्से पर भार के लिए, जहाँ भार शुरू होता है वहाँ एक नोड डालकर सदस्य को बाँट दें: अतिरिक्त नोड कोई परिणाम नहीं बदलता। बिंदु भार या युग्म सदस्य पर कहीं भी हो सकता है।

वैश्विक या स्थानीय अक्ष

अंतिम argument, lcs, बताता है कि घटक किन अक्षों में हैं:

  • false: वैश्विक x और z। सदस्य का ढलान कुछ भी हो, fz ऊर्ध्वाधर लगता है।
  • true: सदस्य का स्थानीय x (उसके अनुदिश) और z (उसके आर-पार)। fz सदस्य के लंबवत लगता है।

बाएँ से दाएँ बने क्षैतिज सदस्य पर दोनों एक ही हैं; दाएँ से बाएँ बने सदस्य पर स्थानीय fz ऊपर की ओर होता है।

भार बदलना या हटाना

हर create… method भार लौटाता है। उसके मान बदलें और फिर से हल करें:

TypeScript
const q = lc.createBeamElementUniformEdgeLoad(1, [0, 10e3], true)
solver.solve()
q.values = [0, 20e3] // दोगुना भार
solver.solve()

भार साधारण arrays में रहते हैं, lc.nodalLoadList और lc.elementLoadList (सदस्य और तापीय भार), इसलिए lc.elementLoadList.splice(index, 1) एक भार हटा देता है। हर भार के property नाम API संदर्भ में हैं।

तापमान परिवर्तन और सपोर्ट का धँसाव भी भार ही हैं: देखें तापमान और सपोर्ट का धँसाव।