Article précédent était au programme de fabrication de la matrice de rigidité des éléments, donc cette fois, je vais expliquer le programme pour créer la matrice de rigidité globale à partir de la matrice de rigidité des éléments. .. Comme la dernière fois, nous nous référons à Méthode du premier élément fini de Java publiée par Corona.
La dernière fois, j'ai créé une matrice de rigidité d'élément et une équation de rigidité d'élément pour un élément d'un objet. Nous formulerons cela pour chaque élément de l'objet. Si un élément i a des nœuds j, k, alors la matrice de rigidité de l'élément et l'équation de la rigidité de l'élément
{\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)
Peut être écrit comme. Par exemple, s'il y a 3 éléments et que le i-ème élément a 2 nœuds (i, i + 1), l'équation de rigidité de l'élément est la suivante.
\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)
Considérant que chaque élément partage chaque nœud, ces équations peuvent être combinées en une seule,
\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)
Ce sera. La somme des équations de rigidité des éléments de cette manière est appelée équation de rigidité globale, et la matrice de coefficients sur le côté gauche est appelée matrice de rigidité globale. La contrainte et la déformation totales sont calculées en résolvant l'équation de rigidité totale en tenant compte de la force externe et des conditions aux limites.
Lorsque les coordonnées du nœud, le rapport aire / Young de l'élément, la force appliquée au nœud et la condition de contrainte de déplacement de nœud de chaque nœud sont saisis, le programme qui sort l'équation de rigidité globale correspondante est le suivant. (La force appliquée aux nœuds et les conditions de contrainte de déplacement des nœuds pour chaque nœud ne sont pas utilisées cette fois, mais ils seront des paramètres nécessaires lors de la résolution de la prochaine équation de rigidité globale.) Dans le programme, la classe Element créée la dernière fois est utilisée. Je vais.
import numpy as np
#Saisie des données et préparation des calculs
#list_x :Coordonnées des nœuds
#list_area :Zone de chaque élément
#list_young :Taux jeune de chaque élément
#list_force :Force appliquée à chaque nœud
#list_nodeCondition :Condition de contrainte de déplacement nodal de chaque nœud
def __init__(self,list_x,list_area,list_young,list_force,list_nodeCondition):
#Définition du nombre de nœuds NumberOfNode, nnode
self.NumberOfNode = int(list_x.shape[0])
nnode = self.NumberOfNode
#Définition du nombre d'éléments NumberOfElement, nelm
self.NumberOfElement = nnode-1
nelm = self.NumberOfElement
#Créez des listes et des tableaux pour le stockage, le calcul et la sortie des données
self.x = np.zeros(nnode) #Coordonnées nodales
self.force = np.zeros(nnode) #Force sur le nœud
self.nodeCondition = np.zeros((nnode,2)) #Condition de contrainte de déplacement nodal
self.totalStiffness = np.zeros((nnode,nnode))#Matrice de rigidité globale
self.disp = np.zeros(nnode) #Déplacement nodal
self.stress = np.zeros(nelm) #stress
#Liste de stockage des classes d'élément
self.elem = np.array([])
#Stockage des conditions initiales des coordonnées des nœuds, de la force appliquée aux nœuds et des conditions de déplacement des nœuds
self.x = list_x
self.force = list_force
self.nodeCondition = list_nodeCondition
#Créer une classe d'élément et stocker dans la liste des éléments
#Ensuite, stockez les données sur l'élément. Implémenté pour le nombre d'éléments.
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):
#Stocke les numéros de contact ix et les coordonnées xe qui composent chaque élément
self.elem[i].ix[j]=i+j
self.elem[i].xe[j]=list_x[i+j]
#Préparation de la matrice de rigidité totale
def assembleMatrix(self):
#Création de matrice de rigidité Bmatrix / élément pour chaque élément
print("\nAssemble Stiffness Matrix : \n")
nelm = self.NumberOfElement
for i in range(nelm):
self.elem[i].makeBmatrix()
self.elem[i].makeElementStiffness()
#Créer une matrice de rigidité globale à partir de chaque matrice de rigidité d'élément
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]
L'exemple d'opération ci-dessus est le suivant. Ici, on suppose qu'il y a quatre nœuds, chaque coordonnée de coordonnées est (50, 150, 250, 350) (mm), la section transversale de chaque élément est de 100 mm $ ^ 2 $ et le taux de Young est de 200 GPa. De plus, bien que non utilisé cette fois, list_nodeCondition spécifie que la coordonnée du nœud est fixée à 50 mm, et list_force spécifie qu'une force de 1000 N peut être appliquée à la coordonnée du nœud de 350 mm.
contribution
#paramètres de nœud
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]])
#Paramètres d'élément
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)
production
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.]]
Cette fois, j'ai expliqué la formule de l'équation de rigidité globale à partir de l'équation de rigidité des éléments et j'ai présenté le programme global de fabrication de la matrice de rigidité. La prochaine fois, je présenterai un programme qui applique les conditions aux limites de déplacement et calcule l'équation de rigidité globale (matrice de rigidité globale).
Shigeru Nagagi (2010) "La première méthode des éléments finis de Java" Corona
Recommended Posts