Mini projet MEF
Analyse numérique
Appliquée
Département : DMS
Sous-groupe 15 :
-Zaoui Mohamed Yazid
-Ouchefoun Aimen
-Khellaf Abd Salame
-Baira taha
Encadré par :
- M.bekhouche
Introduction
Dans le domaine de l'ingénierie des structures, la modélisation et l'analyse des
déformations sous charges sont essentielles pour assurer la sécurité et la stabilité des
constructions. La méthode des éléments finis (FEM) est un outil puissant utilisé pour
analyser des structures complexes en divisant le domaine en éléments plus simples et en
résolvant les équations de mouvement pour ces éléments.
Le script Python présenté ici est une implémentation de la méthode des éléments finis
appliquée à une structure 2D en treillis. L'objectif principal est de déterminer les
déplacements nodaux résultant de charges appliquées sur la structure et de visualiser ces
déplacements pour évaluer la performance et la sécurité de la structure.
L'objectif de ce script est de :
1. Générer un maillage : Créer les nœuds et les éléments nécessaires pour
représenter la structure en treillis.
2. Assembler la matrice de rigidité globale : Calculer la rigidité de chaque
élément et assembler ces rigidités dans une matrice globale représentant la
structure entière.
3. Appliquer les conditions aux limites : Imposer des déplacements nuls aux
nœuds fixes et appliquer des forces aux nœuds chargés.
4. Résoudre le système linéaire : Déterminer les déplacements des nœuds en
résolvant le système d'équations linéaires formé par la matrice de rigidité et
les forces appliquées.
5. Visualiser les résultats : Tracer les déplacements des nœuds pour visualiser
la distribution des déformations dans la structure.
Les étapes générer les graphiques et la résolution de l’exercices.
1- Fonction de Forme
def forme(xi: Tuple[float, float]) -> np.ndarray:
x, y = xi
N = [(1.0 - x) * (1.0 - y), (1.0 + x) * (1.0 - y), (1.0 + x) * (1.0 + y), (1.0 - x) * (1.0 + y)]
return 0.25 * np.array(N)
Cette fonction calcule les fonctions de forme pour un élément quadrangulaire en fonction des
coordonnées locales (xi, eta).
2- Gradient de la Fonction de Forme
def grad_forme(xi: Tuple[float, float]) -> np.ndarray:
x, y = xi
dN = [[-(1.0 - y), (1.0 - y), (1.0 + y), -(1.0 + y)],
[-(1.0 - x), -(1.0 + x), (1.0 + x), (1.0 - x)]]
return 0.25 * np.array(dN)
Cette fonction calcule le gradient des fonctions de forme pour un élément quadrangulaire en
fonction des coordonnées locales (xi, eta)
3- Création des Nœuds
def creer_noeuds(num_noeuds_x: int, num_noeuds_y: int, longueur_x: float, longueur_y: float) ->
np.ndarray:
noeuds = []
for y in np.linspace(0.0, longueur_y, num_noeuds_y):
for x in np.linspace(0.0, longueur_x, num_noeuds_x):
noeuds.append([x, y])
return np.array(noeuds)
Cette fonction génère les coordonnées des nœuds pour une grille 2D donnée.
4- Création de la Connectivité des Éléments
def creer_connectivite(num_elements_x: int, num_elements_y: int, num_noeuds_x: int) ->
List[List[int]]:
connectivite = []
for j in range(num_elements_y):
for i in range(num_elements_x):
n0 = i + j * num_noeuds_x
connectivite.append([n0, n0 + 1, n0 + 1 + num_noeuds_x, n0 + num_noeuds_x])
return connectivite
Cette fonction crée la connectivité des éléments, c'est-à-dire les indices des nœuds qui forment
chaque élément.
5- Assemblage de la Matrice de Rigidité
def assembler_matrice_rigidite(noeuds: np.ndarray, connectivite: List[List[int]], C: np.ndarray) ->
np.ndarray:
num_noeuds = len(noeuds)
K = np.zeros((2 * num_noeuds, 2 * num_noeuds))
points_Gauss = [[x / math.sqrt(3.0), y / math.sqrt(3.0)] for y in [-1.0, 1.0] for x in [-1.0, 1.0]]
B = np.zeros((3, 8))
for element in connectivite:
coords_element = noeuds[element, :]
Ke = np.zeros((8, 8))
for point in points_Gauss:
dN = grad_forme(point)
J = np.dot(dN, coords_element).T
dN = np.dot(np.linalg.inv(J), dN)
B[0, 0::2] = dN[0, :]
B[1, 1::2] = dN[1, :]
B[2, 0::2] = dN[1, :]
B[2, 1::2] = dN[0, :]
Ke += np.dot(np.dot(B.T, C), B) * np.linalg.det(J)
for i, I in enumerate(element):
for j, J in enumerate(element):
K[2 * I, 2 * J] += Ke[2 * i, 2 * j]
K[2 * I + 1, 2 * J] += Ke[2 * i + 1, 2 * j]
K[2 * I + 1, 2 * J + 1] += Ke[2 * i + 1, 2 * j + 1]
K[2 * I, 2 * J + 1] += Ke[2 * i, 2 * j + 1]
return K
Cette fonction assemble la matrice de rigidité globale à partir des matrices de rigidité élémentaires
calculées pour chaque élément.
6- Application des Conditions aux Limites
def appliquer_conditions_limites(K: np.ndarray, forces: np.ndarray, noeuds: np.ndarray,
longueur_y: float) -> None:
num_noeuds = len(noeuds)
for i in range(num_noeuds):
if noeuds[i, 1] == 0.0:
K[2 * i, :] = 0.0
K[2 * i + 1, :] = 0.0
K[2 * i, 2 * i] = 1.0
K[2 * i + 1, 2 * i + 1] = 1.0
if noeuds[i, 1] == longueur_y:
x = noeuds[i, 0]
forces[2 * i + 1] = 20.0
if x == 0.0 or x == longueur_x:
forces[2 * i + 1] *= 0.5
Cette fonction applique les conditions aux limites sur la matrice de rigidité et le vecteur des forces
7- Résolution du Système Linéaire
def resoudre_systeme(K: np.ndarray, forces: np.ndarray) -> np.ndarray:
return np.linalg.solve(K, forces)
Cette fonction résout le système d'équations linéaires pour obtenir les déplacements nodaux.
8- Tracé du Déplacement
def tracer_deplacement(deplacements: np.ndarray, num_noeuds_x: int, num_noeuds_y: int,
taille_x: float, taille_y: float) -> None:
deplacement_x = np.reshape(deplacements[0::2], (num_noeuds_y, num_noeuds_x))
deplacement_y = np.reshape(deplacements[1::2], (num_noeuds_y, num_noeuds_x))
vecteur_x = []
vecteur_y = []
resultat = []
for i in range(num_noeuds_x):
for j in range(num_noeuds_y):
vecteur_x.append(i * taille_x + deplacement_x[j, i])
vecteur_y.append(j * taille_y + deplacement_y[j, i])
resultat.append(deplacement_y[j, i])
traces = plt.tricontourf(vecteur_x, vecteur_y, resultat, levels=14, cmap=plt.cm.jet)
plt.scatter(vecteur_x, vecteur_y, marker='o', c='b', s=2)
plt.grid()
plt.colorbar(traces)
plt.title('Déplacement')
plt.xlabel('Position x')
plt.ylabel('Position y')
plt.axis('equal')
plt.show()
Cette fonction trace les déplacements nodaux en utilisant matplotlib pour visualiser les
résultats.
Les résultats obtenus de se script :
conclusion
L'analyse a permis de modéliser et de visualiser les déplacements d'une structure en
treillis 2D sous charges, en utilisant la méthode des éléments finis (FEM). Les
principales conclusions sont :
1. Déplacements Maximaux : Le calcul des déplacements maximaux a identifié
les zones critiques de la structure.
2. Distribution des Déplacements : La visualisation a montré les régions les plus
déformées, permettant d'évaluer la répartition des contraintes.
3. Validation des Modèles : Les résultats ont confirmé les hypothèses de
modélisation et les conditions aux limites appliquées.
Pistes de Réflexion pour des Travaux Futurs
1. Analyse Non-Linéaire : Étudier les comportements non-linéaires pour des
charges extrêmes.
2. Optimisation de la Structure : Améliorer la conception pour minimiser le
poids tout en assurant la sécurité.
3. Durabilité : Analyser la fatigue et la durabilité pour prévoir la longévité de la
structure.
4. Charges Dynamiques : Évaluer la réponse de la structure aux charges
dynamiques comme les séismes.
5. Validation Expérimentale : Comparer les résultats numériques avec des
données expérimentales pour affiner les modèles.
