Méthode des éléments limités Début 2 (Préparation d'une matrice de rigidité globale unidimensionnelle)

À propos de cet article

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.

Méthode des éléments finis unidimensionnels (fabrication de matrice de rigidité totale)

Combinez les matrices de rigidité des éléments pour créer une matrice de rigidité globale

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.

Programme de calcul de la matrice de rigidité totale des éléments unidimensionnels

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.]]

Résumé

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

Livre de référence

Shigeru Nagagi (2010) "La première méthode des éléments finis de Java" Corona

Recommended Posts

Méthode des éléments limités Début 2 (Préparation d'une matrice de rigidité globale unidimensionnelle)
Le début de la méthode des éléments finis (matrice de rigidité des éléments unidimensionnels)
Mémorandum d'introduction du modèle de données EXODUS de la méthode des éléments finis (FEM)