API संदर्भ

@edubeam/fem 0.3 क्या export करता है, उपयोग के अनुसार समूहों में। इकाइयाँ हर जगह SI हैं: m, N, N·m, N/m, Pa, K और rad। लेबल (LabelType) string | number होते हैं और स्ट्रिंग के रूप में संग्रहीत होते हैं। जो methods यहाँ सूचीबद्ध नहीं हैं, वे आंतरिक हैं: वे TypeScript में public केवल इसलिए हैं क्योंकि सॉल्वर की अपनी classes उन्हें कॉल करती हैं।

Exports

Exportप्रकारखंड
LinearStaticSolverclassविश्लेषण
Solverabstract classविश्लेषण
DomainclassDomain
NodeclassNode
Beam2D, Elementclassesअवयव
Material, CrossSectionclassesसामग्री और अनुप्रस्थ काट
LoadCaseclassभार
NodalLoad, BeamConcentratedLoad, BeamElementUniformEdgeLoad, BeamElementTrapezoidalEdgeLoad, BeamTemperatureLoad, PrescribedDisplacement, Load, BeamElementLoadclassesभार
DofIDenumDofID
LabelType, EnumDictionary, MaterialParameters, CrossSectionParameterstypes

विश्लेषण

LinearStaticSolver

TypeScript
const solver = new LinearStaticSolver()
Memberप्रकारविवरण
domainDomainमॉडल
loadCasesLoadCase[]एक लोड केस, 'DefaultLC', से शुरू होता है। और लोड केस new LoadCase(label, solver.domain) से push करें: लोड केस।
solve()voidज़रूरत हो तो समीकरणों का क्रमांकन करता है, फिर हर लोड केस को असेंबल करके हल करता है। यंत्र पर त्रुटि फेंक सकता है, पर हमेशा नहीं। 0.3.1 से कुछ नहीं छापता; 0.3.0 अपना समय log करता था।
codeNumberGeneratedbooleanनोड या सदस्य जोड़ने या हटाने, या सपोर्ट बदलने के बाद इसे false करें: क्यों
neq, pneqnumberमुक्त और सपोर्ट वाली DOF की संख्या, हल के बाद
kmathjs Matrixअसेंबल किया गया वैश्विक कठोरता मैट्रिक्स, हल के बाद
getNodeDofIDs(label)number[]नोड की DOF, हल के बाद

EigenValueDynamicSolver स्रोत कोड में है, पर export नहीं होता।

Domain

solver.domain मॉडल को चार Map में रखता है, जिनकी keys स्ट्रिंग के रूप में लेबल हैं: nodes, elements, materials, crossSections। हटाने के कोई methods नहीं हैं: domain.nodes.delete(label) और domain.elements.delete(label) कोई नोड या सदस्य हटाते हैं, जिसके बाद फिर से क्रमांकन करें।

Methodलौटाता हैविवरण
createNode(label, coords?, bcs?)Nodecoords [x, y, z] m में (डिफ़ॉल्ट [0, 0, 0]), bcs सपोर्ट वाली DofID (डिफ़ॉल्ट कोई नहीं)
createBeam2D(label, nodes, mat, cs, hinges?)Beam2Dnodes [first, second], hinges [atFirst, atSecond] (डिफ़ॉल्ट [false, false])
createMaterial(label, params?)Materialदेखें सामग्री और अनुप्रस्थ काट
createCrossSection(label, params?)CrossSectionदेखें सामग्री और अनुप्रस्थ काट
getNode(label), getElement(label), getMaterial(label), getCS(label)वह objectअज्ञात लेबल पर RangeError फेंकता है। getElement का type Element है: परिणाम पढ़ने के लिए as Beam2D लिखें।

पहले से उपयोग में आए लेबल से object बनाने पर पुराना object बदल जाता है।

Node

Memberप्रकारविवरण
labelstring
coordsnumber[][x, y, z], m। नोड खिसकाने के लिए इसे बदलें।
bcsSet<DofID>सपोर्ट वाली DOF। सपोर्ट बदलने के लिए इसे बदलें।
lcsnumber[][] | undefinedनोड के घुमाए गए अक्ष, यदि हों
updateLcs({ locx, locy }?)voidनोड के अक्ष घुमाता है: locx वैश्विक घटकों में उसका x अक्ष, locy [0, 1, 0]। बिना argument के अक्ष वापस मूल स्थिति में आते हैं।
hasLcs()booleanक्या अक्ष घुमाए गए हैं
getUnknowns(lc, dofs)Matrix, या एक DOF के लिए numberविस्थापन (m) और घूर्णन (rad), नोड के अक्षों में
getReactions(lc, global?){ dofs, values }सपोर्ट वाली DOF पर प्रतिक्रियाएँ, bcs के क्रम में: N, N·m। कई हों तो values एक mathjs Matrix है, एक हो तो एक तत्व वाला array, मुक्त नोड के लिए []। घुमाए गए नोड पर global true के साथ: वैश्विक अक्षों में तीनों DOF, dofs [0, 2, 4], values एक array जिसमें जहाँ कुछ रोका नहीं गया वहाँ 0। इन्हें पढ़ना।

अवयव

Beam2D

x–z समतल में दो नोडों वाला Timoshenko बीम, हर नोड पर तीन DOF (Dx, Dz, Ry)। x पहले नोड से मीटर में है; n खंडों की संख्या है, जिससे n + 1 बिंदु मिलते हैं।

Memberलौटाता हैविवरण
label, nodes, mat, csstring, string[], string, string
hinges[boolean, boolean]पहले और दूसरे नोड पर आघूर्ण मुक्ति
computeNormalForceAt(lc, x)numberN, तनाव धनात्मक
computeShearForceAt(lc, x)numberV, धनात्मक जहाँ M स्थानीय x के अनुदिश बढ़ता है
computeBendingMomentAt(lc, x)numberM, धनात्मक जब स्थानीय +z की ओर तनाव हो
computeNormalForce(lc, n){ x, N }n + 1 बिंदुओं पर N
computeShearForce(lc, n){ x, V }n + 1 बिंदुओं पर V
computeBendingMoment(lc, n){ x, M }n + 1 बिंदुओं पर M
computeLocalDefl(lc, n){ u, w }सदस्य के अनुदिश और आर-पार विस्थापन, स्थानीय अक्ष, m
computeGlobalDefl(lc, n){ u, w }वही, वैश्विक x और z में
computeEndForces(lc)Matrix[X12, Z12, M12, X21, Z21, M21], वे बल जो नोड सदस्य पर लगाते हैं, स्थानीय अक्ष
computeEndDisplacement(lc)Matrixस्थानीय अक्षों में सिरों के विस्थापन, हिंज के घूर्णन सहित
computeGeo(){ l, dx, dz }लंबाई और प्रक्षेप, m
computeT()Matrix6 × 6 रूपांतरण, वैश्विक से स्थानीय
computeLocalStiffnessMtrx(){ answer }answer: 6 × 6 स्थानीय कठोरता, हिंज वाले घूर्णन संघनित करके हटाए गए
computeStiffness()Matrix6 × 6 वैश्विक कठोरता
computeShearFactor()number
getMaterial(), getCS()Material, CrossSection

बिंदु भार पर …At methods उसके ठीक आगे का मान लौटाते हैं। Element, Beam2D की abstract base class है; domain.elements और getElement यही type इस्तेमाल करते हैं।

सामग्री और अनुप्रस्थ काट

MaterialParametersइकाईडिफ़ॉल्टकिसके लिए
ePa1कठोरता
gPa1अपरूपण कठोरता
alpha1/K1तापीय भार
dkg/m³1स्थैतिकी में किसी काम का नहीं
CrossSectionParametersइकाईडिफ़ॉल्टकिसके लिए
am²कोई नहीं, अनिवार्यअक्षीय और अपरूपण कठोरता
iym⁴कोई नहीं, अनिवार्यबंकन कठोरता
k–कोई नहीं, अनिवार्यअपरूपण कठोरता ; अपरूपण विरूपण न चाहिए तो 1e32
hmकोई नहींतापमान प्रवणता (इसके बिना NaN)
iz, dyz, jm⁴कोई नहींBeam2D इनका उपयोग नहीं करता

सामग्री का छूटा पैरामीटर 1 होता है, कोई सामान्य मान नहीं; a, iy या k छूट जाए, तो हर परिणाम NaN होता है। दोनों में कोई त्रुटि नहीं आती। दोनों classes में एक change(params) method है जो दिए गए पैरामीटर सेट करता है, और दोनों उन्हें इन्हीं नामों की properties के रूप में रखती हैं।

भार

LoadCase

Methodलौटाता हैमान
createNodalLoad(node, values, lcs?)NodalLoad{ [DofID.Dx]: N, [DofID.Dz]: N, [DofID.Ry]: N·m }; lcs (डिफ़ॉल्ट false) true: नोड के घुमाए गए अक्षों में
createBeamElementUniformEdgeLoad(el, [fx, fz], lcs)BeamElementUniformEdgeLoadपूरे सदस्य पर N/m
createBeamElementTrapezoidalEdgeLoad(el, [fx1, fz1], [fx2, fz2], lcs)BeamElementTrapezoidalEdgeLoadपहले और दूसरे नोड पर N/m, बीच में रैखिक
createBeamConcentratedLoad(el, [fx, fz, my, a], lcs)BeamConcentratedLoadN, N, N·m, पहले नोड से a m पर
createBeamTemperatureLoad(el, [dTc, dTb, dTt])BeamTemperatureLoadK: केंद्रक, निचला तंतु, ऊपरी तंतु
createPrescribedDisplacement(node, values)PrescribedDisplacement{ [DofID.Dz]: m, … } सपोर्ट वाली DOF पर, नोड के अक्षों में; मुक्त DOF पर अनदेखा

सदस्य भारों के लिए lcs true का अर्थ है स्थानीय अक्ष (x सदस्य के अनुदिश, z उसके आर-पार), और false वैश्विक अक्ष। रेखीय भार सदस्य की लंबाई के प्रति मीटर होते हैं। उदाहरण नोडल और सदस्य भार पृष्ठ पर हैं।

Memberप्रकारविवरण
labelstring
nodalLoadListNodalLoad[]
elementLoadListBeamElementLoad[]सदस्य भार और तापीय भार
prescribedBCPrescribedDisplacement[]
solvedbooleanसफल हल के बाद true
getElementLoadsOnElement(el)BeamElementLoad[]एक सदस्य पर लगे भार

भार objects अपने मान public properties में रखते हैं, जिन्हें दोबारा हल करने से पहले आप बदल सकते हैं: NodalLoad, BeamElementUniformEdgeLoad, BeamConcentratedLoad और BeamTemperatureLoad पर values (और lcs); BeamElementTrapezoidalEdgeLoad पर startValues और endValues; PrescribedDisplacement पर prescribedValues। हर एक का एक target होता है, वह लेबल जिस पर वह लगता है।

DofID

नाममानBeam2D उपयोग करता है
Dx0हाँ
Dy1नहीं
Dz2हाँ
Rx3नहीं
Ry4हाँ
Rz5नहीं

परिणाम

परिणाम Beam2D से (आंतरिक बल, विक्षेप, सिरा-बल) और Node से (विस्थापन, प्रतिक्रियाएँ) पढ़े जाते हैं, हमेशा किसी दिए गए LoadCase के लिए, solve() के बाद: ऊपर की दोनों तालिकाएँ देखें, और उदाहरणों और चिह्नों के लिए परिणाम पढ़ना। संक्षेप में:

क्या चाहिएकॉल
प्रतिक्रियाएँ, N और N·mnode.getReactions(lc)
विस्थापन, m, और घूर्णन, radnode.getUnknowns(lc, [DofID.Dx, DofID.Dz, DofID.Ry])
किसी बिंदु पर N, V या M, N और N·mbeam.computeNormalForceAt(lc, x), computeShearForceAt, computeBendingMomentAt
सदस्य के अनुदिश N, V या Mbeam.computeNormalForce(lc, n), computeShearForce, computeBendingMoment
विरूपित आकार, mbeam.computeLocalDefl(lc, n), computeGlobalDefl
सिरा-बल, N और N·mbeam.computeEndForces(lc)
इन सबका चित्र@edubeam/plot का StructurePlot या structureSvg