Vorheriger Artikel war dem Herstellungsprogramm für die Elementsteifigkeitsmatrix gewachsen, daher werde ich dieses Mal das Programm zum Erstellen der Gesamtsteifigkeitsmatrix aus der Elementsteifigkeitsmatrix erläutern. .. Ähnlich wie in der vorherigen Zeit basiert es auf Die erste Finite-Elemente-Methode von Java, die von Corona veröffentlicht wurde.
Letztes Mal habe ich eine Elementsteifigkeitsmatrix und eine Elementsteifigkeitsgleichung für ein Element eines Objekts erstellt. Wir werden dies für jedes Element im Objekt formulieren. Wenn ein Element i Knoten j, k hat, dann die Elementsteifigkeitsmatrix und die Elementsteifigkeitsgleichung
{\bf K}^{(i)} \left(
\begin{array}{c}
u_j \\
u_k
\end{array}
\right)
=
\left(
\begin{array}{c}
K_{11}^{(i)}\ K_{12}^{(i)} \\
K_{21}^{(i)}\ K_{22}^{(i)}
\end{array}
\right)
\left(
\begin{array}{c}
u_j \\
u_k
\end{array}
\right)
=
\left(
\begin{array}{c}
f^{(i)}_j \\
f^{(i)}_k
\end{array}
\right)
(1)
Kann geschrieben werden als. Wenn beispielsweise drei Elemente vorhanden sind und das i-te Element zwei Knoten (i, i + 1) hat, lautet die Elementsteifigkeitsgleichung wie folgt.
\left(
\begin{array}{c}
K_{11}^{(1)}\ K_{12}^{(1)} \\
K_{21}^{(1)}\ K_{22}^{(1)}
\end{array}
\right)
\left(
\begin{array}{c}
u_1 \\
u_2
\end{array}
\right)
=
\left(
\begin{array}{c}
f^{(1)}_1 \\
f^{(1)}_2
\end{array}
\right)
(2)
\left(
\begin{array}{c}
K_{11}^{(2)}\ K_{12}^{(2)} \\
K_{21}^{(2)}\ K_{22}^{(2)}
\end{array}
\right)
\left(
\begin{array}{c}
u_2 \\
u_3
\end{array}
\right)
=
\left(
\begin{array}{c}
f^{(2)}_2 \\
f^{(2)}_3
\end{array}
\right)
(3)
\left(
\begin{array}{c}
K_{11}^{(3)}\ K_{12}^{(3)} \\
K_{21}^{(3)}\ K_{22}^{(3)}
\end{array}
\right)
\left(
\begin{array}{c}
u_3 \\
u_4
\end{array}
\right)
=
\left(
\begin{array}{c}
f^{(3)}_3 \\
f^{(3)}_4
\end{array}
\right)
(4)
Wenn man bedenkt, dass jedes Element jeden Knoten teilt, können diese Gleichungen zu einem kombiniert werden:
\left(
\begin{array}{cccc}
K_{11}^{(1)}& K_{12}^{(1)} & 0 & 0 \\
K_{21}^{(1)}& K_{22}^{(1)} + K_{11}^{(2)} & K_{12}^{(2)} & 0 \\
0 & K_{21}^{(2)} & K_{22}^{(2)} + K_{11}^{(3)} & K_{12}^{(3)} \\
0 & 0 & K_{21}^{(3)} & K_{22}^{(3)} \\
\end{array}
\right)
\left(
\begin{array}{c}
u_1 \\
u_2 \\
u_3 \\
u_4
\end{array}
\right)
=
\left(
\begin{array}{c}
f^{(1)}_1\\
f^{(1)}_2+f^{(2)}_2 \\
f^{(2)}_3+f^{(3)}_3 \\
f^{(3)}_4
\end{array}
\right)
(5)
Es wird sein. Die Summe der Elementsteifigkeitsgleichungen auf diese Weise wird als Gesamtsteifigkeitsgleichung bezeichnet, und die Koeffizientenmatrix auf der linken Seite wird als Gesamtsteifigkeitsmatrix bezeichnet. Die Gesamtspannung und -dehnung werden berechnet, indem die Gesamtsteifigkeitsgleichung unter Berücksichtigung der äußeren Kraft und der Randbedingungen gelöst wird.
Wenn die Knotenkoordinaten, das Flächen / Young-Verhältnis des Elements, die auf den Knoten ausgeübte Kraft und die Bedingung für die Knotenverschiebungsbeschränkung jedes Knotens eingegeben werden, lautet das Programm, das die entsprechende Gesamtsteifigkeitsgleichung ausgibt, wie folgt. (Die auf die Knoten ausgeübte Kraft und die Bedingungen für die Knotenverschiebungsbeschränkung für jeden Knoten werden dieses Mal nicht verwendet, sie sind jedoch notwendige Parameter beim Lösen der nächsten Gesamtsteifigkeitsgleichung.) Im Programm wird die zuletzt erstellte Elementklasse verwendet. Ich werde.
import numpy as np
#Dateneingabe und Berechnungsvorbereitung
#list_x :Knotenkoordinaten
#list_area :Fläche jedes Elements
#list_young :Young Rate jedes Elements
#list_force :Kraft, die auf jeden Knoten angewendet wird
#list_nodeCondition :Knotenverschiebungsbeschränkungsbedingung jedes Knotens
def __init__(self,list_x,list_area,list_young,list_force,list_nodeCondition):
#Festlegen der Anzahl der Knoten NumberOfNode, nnode
self.NumberOfNode = int(list_x.shape[0])
nnode = self.NumberOfNode
#Festlegen der Anzahl der Elemente NumberOfElement, nelm
self.NumberOfElement = nnode-1
nelm = self.NumberOfElement
#Erstellen Sie Listen und Arrays zur Speicherung, Berechnung und Ausgabe von Daten
self.x = np.zeros(nnode) #Knotenkoordinaten
self.force = np.zeros(nnode) #Kraft auf den Knoten
self.nodeCondition = np.zeros((nnode,2)) #Bedingung der Knotenverschiebungsbeschränkung
self.totalStiffness = np.zeros((nnode,nnode))#Gesamtsteifigkeitsmatrix
self.disp = np.zeros(nnode) #Knotenverschiebung
self.stress = np.zeros(nelm) #Stress
#Liste zum Speichern von Elementklassen
self.elem = np.array([])
#Speicherung der Anfangsbedingungen der Knotenkoordinaten, der auf die Knoten ausgeübten Kraft und der Knotenverschiebungsbedingungen
self.x = list_x
self.force = list_force
self.nodeCondition = list_nodeCondition
#Elementklasse erstellen und in Elementliste speichern
#Speichern Sie dann die Daten zum Element. Implementiert für die Anzahl der Elemente.
for i in range(nelm):
self.elem = np.append(self.elem, Element())
self.elem[i].young=list_young[i]
self.elem[i].area=list_area[i]
for j in range(2):
#Speichert die Kontaktnummern ix und die Koordinaten xe, aus denen jedes Element besteht
self.elem[i].ix[j]=i+j
self.elem[i].xe[j]=list_x[i+j]
#Vorbereitung der Gesamtsteifigkeitsmatrix
def assembleMatrix(self):
#Erstellung einer Bmatrix- / Elementsteifigkeitsmatrix für jedes Element
print("\nAssemble Stiffness Matrix : \n")
nelm = self.NumberOfElement
for i in range(nelm):
self.elem[i].makeBmatrix()
self.elem[i].makeElementStiffness()
#Erstellen Sie aus jeder Elementsteifigkeitsmatrix eine Gesamtsteifigkeitsmatrix
for k in range(nelm):
print(" Element",k)
for i in range(2):
for j in range(2):
ii = int(self.elem[k].ix[i])
jj = int(self.elem[k].ix[j])
self.totalStiffness[ii,jj] += self.elem[k].Kmatrix[i,j]
Das obige Operationsbeispiel lautet wie folgt. Hier wird angenommen, dass es vier Knoten gibt, jede Koordinatenkoordinate (50, 150, 250, 350) (mm) ist, die Querschnittsfläche jedes Elements 100 mm $ ^ 2 $ beträgt und die Young-Rate 200 GPa beträgt. Obwohl diesmal nicht verwendet, gibt list_nodeCondition an, dass die Knotenkoordinate auf 50 mm festgelegt ist, und list_force gibt an, dass eine Kraft von 1000 N auf die Knotenkoordinate von 350 mm angewendet werden kann.
Eingang
#Knotenparameter
list_x = np.array([50,150,250,350])
list_force = np.array([0.0,0.0,0.0,1000.])
list_nodeCondition = np.array([[1,0],[0,0],[0,0],[0,0]])
#Elementparameter
list_area = np.array([100,100,100])
list_young = np.array([200000,200000,200000])
Fem = Fem1dim(list_x,list_area,list_young,list_force,list_nodeCondition)
Fem.assembleMatrix()
print(Fem.totalStiffness)
Ausgabe
Assemble Stiffness Matrix :
Element 0
Element 1
Element 2
[[ 200000. -200000. 0. 0.]
[-200000. 400000. -200000. 0.]
[ 0. -200000. 400000. -200000.]
[ 0. 0. -200000. 200000.]]
Dieses Mal erklärte ich die Formel der Gesamtsteifigkeitsgleichung aus der Elementsteifigkeitsgleichung und stellte das Herstellungsprogramm für die Gesamtsteifigkeitsmatrix vor. Das nächste Mal werde ich ein Programm vorstellen, das Verschiebungsgrenzbedingungen anwendet und die Gesamtsteifigkeitsgleichung (Gesamtsteifigkeitsmatrix) berechnet.
Shigeru Nagagi (2010) "Die erste Finite-Elemente-Methode von Java" Corona