République du Cameroun Republic of Cameroon

Paix - Travail – Patrie Peace - Work - Fatherland

******* *******
Université de Yaoundé I University of Yaoundé I
Sapienta - Collativia – Cognitio Sapienta - Collativia - Cognitio
******** *****
École Nationale Supérieure National Advanced School of
Polytechnique Engineering
******* *******
Département de Genie civil et Department of civil engineering
urbanisme

CONCEPTION ET LE DEVELOPPEMENT D'UN

LOGICIEL DE CALCUL DES EFFORTS SUR UNE
STRUCTURE DECOMPOSABLE EN ELEMENTS
FINIS A 1D, 2D ET 3D
Rédigé et présenté par : le groupe 9
NOMS MATRICULE
NGOUEKO KENFACK Loli Carelle 20p391

DOMBOU TCHUDJIN Ange Cabrelle 20p100

MAMTO TIAM Annaele 22p178

NDONGO Ruphin Junior 20p317
EDO Sergio Parfait 20p280
EYILI EYONO Josiane 20p259
NDZIE AYENE Camille 20p208
NYISSONG ABANDA Samira 20p241
OKONO AMOU’OU Nasser 18p076

Sous supervision de : Dr PETTANG Joyce

Année Académique: 2023-2024

 TABLE DES MATIERES

INTRODUCTION ................................................................................................................................. 2
I. PRESENTATION DU PROJET .................................................................................................. 3
II. SPECIFICATIONS FONCTIONNELLES ............................................................................. 4
1. Fonctionnalités principales ....................................................................................................... 4
2. Interfaces utilisateur ................................................................................................................. 5
3. Formats de données d'entrée et de sortie ................................................................................ 5
4. FONCTIONNALITES TECHNIQUES .................................................................................. 6
III. SPECIFICATIONS NON FONCTIONNELLES ................................................................... 8
1. Convivialité et ergonomie ......................................................................................................... 8
2. Portabilité ................................................................................................................................... 8
3. Maintenance et évolutivité ........................................................................................................ 8
4. Documentation technique ......................................................................................................... 8
5. Contraintes légales et réglementaires ...................................................................................... 9
IV. EXIGENCES DE PERFORMANCE .................................................................................... 10
1. Temps de calcul ....................................................................................................................... 10
2. Capacité de traitement ............................................................................................................ 10
3. Utilisation efficace des ressources .......................................................................................... 10
4. Temps de réponse de l'interface utilisateur .......................................................................... 10
5. Tests de performance .............................................................................................................. 10
V. EXIGENCES DE DOCUMENTATION ................................................................................... 11
VI. CONCEPTION ET ARCHITECTURE DU LOGICIEL .................................................... 12
VII. PROGRAMMATION ET DEVELEPPEMENT DU LOGICIEL ...................................... 14
CONCLUSION .................................................................................................................................... 18

1
 INTRODUCTION

Le présent cahier des charges a pour objectif de définir les spécifications et les exigences pour
la conception et le développement d'un logiciel de calcul des efforts sur une structure
décomposable en éléments finis à 1D, 2D et 3D. Ce logiciel vise à fournir une solution complète
et efficace pour l'analyse des contraintes et des forces internes dans des structures complexes.

2
 I. PRESENTATION DU PROJET
Notre projet de classe porte sur la conception et la réalisation d’un logiciel de calcul des efforts
sur une structure décomposable en éléments finis à 1D, 2D et 3D. Ce logiciel a pour but de nous
aider à simuler et à analyser les structures et les systèmes en utilisant la méthode des éléments
finis. A cet effet, le logiciel permettra aux utilisateurs de saisir les géométries de structures, de
spécifier les propriétés des matériaux, d'appliquer des charges et de calculer les efforts internes
tels que les contraintes et les déformations.

Par conséquent, les utilisateurs potentiels du logiciel sont des ingénieurs de génie civil, des
chercheurs en mécanique de structures ou des étudiants de génie civil.

3
 II. SPECIFICATIONS FONCTIONNELLES
Les spécifications fonctionnelles décrivent les principales fonctionnalités du logiciel de calcul
des efforts sur une structure décomposable en éléments finis à 1D, 2D et 3D, ainsi que les
interfaces utilisateur et les formats de données d'entrée et de sortie.

1. Fonctionnalités principales

Le logiciel devra offrir les fonctionnalités suivantes :

a. Calcul des efforts sur des structures 1D

 Permettre aux utilisateurs de définir des structures 1D en spécifiant les nœuds, les
éléments et les propriétés matérielles.
 Effectuer le calcul des efforts internes tels que les contraintes, les déformations et
les réactions aux appuis.
 Générer des visualisations graphiques des résultats pour faciliter l'analyse et la
compréhension.
b. Calcul des efforts sur des structures 2D
 Prendre en charge l'analyse de structures 2D en permettant la modélisation de
plaques, de poutres et d'autres éléments 2D.
 Permettre aux utilisateurs de spécifier les charges appliquées et les conditions aux
limites.
 Effectuer le calcul des efforts internes, y compris les contraintes, les déformations
et les réactions aux appuis.
 Fournir des outils de visualisation pour afficher les résultats de manière claire et
compréhensible.
c. Calcul des efforts sur des structures 3D
 Offrir la possibilité de modéliser des structures 3D complexes à l'aide d'éléments
finis.
 Prendre en compte les propriétés matérielles, les charges appliquées et les
conditions aux limites.
 Effectuer le calcul des efforts internes, y compris les contraintes, les déformations
et les réactions aux appuis.
 Fournir des fonctionnalités de visualisation avancées pour une analyse
approfondie des résultats tels que des simulation 3D.

4
2. Interfaces utilisateur

Le logiciel doit présenter les interfaces utilisateur suivantes :

a. Interface de saisie des données

Fournir une interface conviviale pour permettre aux utilisateurs de saisir et de modifier les
données relatives à la géométrie de la structure, aux propriétés matérielles, aux charges
appliquées, etc.

Utiliser des formulaires, des menus déroulants et d'autres éléments d'interface intuitifs pour
faciliter la saisie des informations.

b. Interface de visualisation des résultats

Proposer des outils de visualisation graphique pour afficher les résultats du calcul des efforts
de manière claire, compréhensible et interactive.

Permettre aux utilisateurs de zoomer, de faire pivoter et de manipuler les modèles pour une
meilleure analyse visuelle.

Sur cette partie, l’utilisateur devra entrer les paramètres suivants :

 Les coordonnées géométriques en système cartésien pour dire si la structure est en

plan ou tridimensionnel
 Identifier le nombre de réactions aux appuis n pour savoir si l’élément est isostatique
ou hyperstatique
 Si l’élément est isostatique :
 Section S
 Chargement P
 Longueur L
 Distance du premier appui A au début du chargement (α)
 Distance de la fin du chargement au dernier appui B (β)
 Si l’élément est hyperstatique :
 Nombre de travées
 Section S
 Chargement Pi sur les différentes travées
 Longueur Li de chaque travée

3. Formats de données d'entrée et de sortie

Le logiciel devra prendre en charge les formats de données d'entrée et de sortie suivants :

a. Formats d'importation des géométries

5
Permettre l'importation de fichiers de géométrie à partir de formats courants tels que les fichiers
DXF, STL, STEP, etc.

Assurer une conversion précise des géométries importées en une représentation compatible
avec les calculs des efforts.

b. Formats d'exportation des résultats

Offrir la possibilité d'exporter les résultats du calcul des efforts vers des formats courants tels
que les fichiers CSV, les rapports PDF ou les formats de visualisation 3D tels que les fichiers
OBJ, STL, etc.

4. FONCTIONNALITES TECHNIQUES
a. Si n ≤ 3 alors système isostatique (Utilisation des lignes d’influences)
 Calcul des réactions aux appuis

RA= (L- α)

RB= α

 Calcul des efforts internes et déduction du torseur de cohésion

N=0

P(1- ) pour α > x

T(x)=
-P pour α < x

Px(1- ) pour α > x

Mf(x)=
P (L-x) pour α < x

b. Si n > 3 alors système hyperstatique (Utilisation de la méthode des trois moments)

 Réactions aux appuis

RA= (L- α)

RB= α

 Calcul des efforts internes dans les systèmes isostatiques équivalent

N=0

6
 P(1- ) pour α > x
ti(x)=
-P pour α < x

Px(1- ) pour α > x

mif(x)=
P (L-x) pour α < x

 Calcul des moments aux appuis

Mi (i=1,2,3…)

 Calcul des efforts internes dans le système hyperstatique

N=0 Mi-1 Li

-
Ti(x)=ti(x)+

Mi(x)=mi(x)+ Mi-1(1- )+Mi

7
 III. SPECIFICATIONS NON FONCTIONNELLES
Les spécifications non fonctionnelles décrivent les exigences et les contraintes liées à
l'ergonomie, à la portabilité, à la maintenance, à la documentation technique, ainsi qu'aux
contraintes légales et réglementaires du logiciel de calcul des efforts sur une structure
décomposable en éléments finis à 1D, 2D et 3D.

1. Convivialité et ergonomie

Le logiciel sera convivial et intuitif, avec une interface utilisateur ergonomique qui facilite la
saisie des données et l'interaction avec les résultats.

Les menus, les boutons et les fonctionnalités seront organisés de manière logique et cohérente
pour une utilisation aisée par les utilisateurs.

Des indications et des messages d'erreur clairs seront fournis pour guider les utilisateurs lors de
la saisie des données.

2. Portabilité

Le logiciel sera conçu de manière à être compatible avec différents systèmes d'exploitation
courants, tels que Windows, MacOs et Linux.

Il doit être capable de s'exécuter sur différents types d'ordinateurs, y compris les ordinateurs de
bureau, les ordinateurs portables et les stations de travail.

3. Maintenance et évolutivité

Le code source du logiciel sera bien structuré, modulaire et maintenable. Des commentaires et
une documentation appropriée sera fournis pour faciliter la maintenance future du logiciel.

Le logiciel sera conçu de manière à permettre l'ajout de nouvelles fonctionnalités et l'adaptation

aux évolutions futures des besoins.

4. Documentation technique

Une documentation technique complète sera fournie, comprenant des instructions d'installation,
d'utilisation et de configuration du logiciel.

Des exemples d'utilisation, des tutoriels et des guides de référence seront inclus pour aider les
utilisateurs à tirer le meilleur parti du logiciel.

8
5. Contraintes légales et réglementaires

Notre logiciel devra respecter les lois, les réglementations et les normes applicables dans le
domaine de l'ingénierie des structures. Il doit prendre en compte les contraintes de
confidentialité des données et assurer la protection des informations sensibles.

9
 IV. EXIGENCES DE PERFORMANCE
Les exigences de performance décrivent les critères de performance et les contraintes de temps
de réponse pour le logiciel de calcul des efforts sur une structure décomposable en éléments
finis à 1D, 2D et 3D.

1. Temps de calcul

Le logiciel effectuera des calculs d’efforts internes pour des structures de taille moyenne dans
un délai raisonnable.

Les temps de calcul seront optimisés pour assurer une utilisation efficace du logiciel.

Des mesures de performance doivent être effectuées pour garantir que les temps de calcul
restent acceptables même pour les structures complexes.

2. Capacité de traitement

Le logiciel doit être capable de gérer des structures avec un grand nombre de nœuds, d'éléments
et de charges. Il doit être capable de traiter efficacement et de manière fiable des modèles de
structures de taille importante.

3. Utilisation efficace des ressources

Le logiciel doit utiliser efficacement les ressources matérielles disponibles, telles que la
mémoire et le processeur, pour optimiser les performances. Il doit minimiser la consommation
de ressources et éviter les problèmes de surcharge du système.

4. Temps de réponse de l'interface utilisateur

L'interface utilisateur doit être réactive et offrir des temps de réponse rapides lors de la saisie
des données, de la modification des paramètres et de l'affichage des résultats. Les délais de
réponse doivent être suffisamment courts pour offrir une expérience utilisateur fluide et sans
frustration.

5. Tests de performance

Nous devons faire des tests de performance approfondis pour vérifier et valider les exigences
de performance. Ces tests doivent inclure des scénarios de charge élevée et des modèles de
structures complexes pour évaluer les performances réelles du logiciel.

10
 V. EXIGENCES DE DOCUMENTATION
Les exigences de documentation décrivent les livrables documentaires nécessaires pour ce
logiciel.

 Manuel d'utilisation : Un manuel d'utilisation détaillé doit être fourni, expliquant de

manière claire et concise comment installer, configurer et utiliser le logiciel. Le manuel
doit inclure des instructions étape par étape, des captures d'écran et des exemples pour
faciliter la compréhension et l'utilisation du logiciel.
 Guide de l'utilisateur : Un guide de l'utilisateur plus approfondi doit être proposé,
fournissant des informations détaillées sur les fonctionnalités du logiciel et les
meilleures pratiques pour l'analyse des structures. Le guide doit inclure des explications
détaillées des concepts clés, des exemples d'utilisation avancée et des conseils pour
résoudre les problèmes courants.
 Documentation technique : Une documentation technique complète doit être fournie,
décrivant l'architecture du logiciel, les algorithmes utilisés, les interfaces de
programmation et les formats de données. La documentation technique doit être
suffisamment détaillée pour permettre aux développeurs de comprendre et de
personnaliser le logiciel si nécessaire.
 Exemples et tutoriels : Des exemples d'utilisation et des tutoriels démontrant les
fonctionnalités clés du logiciel doivent être inclus. Ces exemples et tutoriels doivent
couvrir différents types de structures et guider les utilisateurs dans l'analyse des charges
et l'interprétation des résultats.
 Notes de version : Des notes de version détaillées doivent être fournies, décrivant les
fonctionnalités nouvelles, modifiées ou supprimées dans chaque version du logiciel. Les
notes de version doivent également inclure des informations sur les correctifs de bogues
et les améliorations de performance.
 Support en ligne : Un support en ligne, tel qu'un site web ou un forum communautaire,
doit être mis en place pour fournir une assistance aux utilisateurs. Ce support en ligne
doit permettre aux utilisateurs de poser des questions, de signaler des problèmes et
d'échanger des connaissances avec d'autres utilisateurs.

11
VI. CONCEPTION ET ARCHITECTURE DU LOGICIEL
INTERFACE UTILISATEUR
 Gère l'interaction avec l'utilisateur.
 Affiche les fonctionnalités du logiciel, les résultats des calculs et les messages
d'erreur.
 Permet à l'utilisateur de définir les propriétés de la structure, les charges appliquées
et les options de calcul.

MODULE DE PRETRAITEMENT
 Reçoit les données d'entrée de l'utilisateur depuis l'interface utilisateur.
 Valide les données et effectue les vérifications préliminaires.
 Convertit les données d'entrée dans un format interne utilisé pour l'analyse des
éléments finis.
 Crée le modèle de la structure en décomposant celle-ci en éléments finis 1D, 2D et
3D.

MODULE D'ANALYSE DES ELEMENTS FINIS

 Applique les méthodes d'analyse des éléments finis pour calculer les efforts sur la
structure.
 Effectue les calculs de déformation, de contrainte, de réaction et d'autres grandeurs
associées : pour poutre isostatique
 Utilise des algorithmes de résolution numérique pour obtenir les résultats des
calculs.

MODULE DE POST-TRAITEMENT
 Traite les résultats des calculs pour les rendre compréhensibles et utilisables par
l'utilisateur.
 Génère des graphiques, des tableaux et d'autres visualisations pour représenter les
efforts sur la structure.
 Permet à l'utilisateur de naviguer et d'explorer les résultats des calculs de manière
interactive.

MODULE DE SAUVEGARDE ET DE CHARGEMENT DE DONNEES

 Gère la sauvegarde et le chargement des modèles de structure, des charges
appliquées et des résultats des calculs.
 Utilise un système de fichiers ou une base de données pour stocker les données de
manière persistante.

12
 MODULE DE GESTION DES ERREURS ET DES EXCEPTIONS
 Détecte et gère les erreurs et les exceptions qui se produisent pendant l'exécution du
logiciel.
 Fournit des messages d'erreur explicites et des mécanismes de récupération pour
guider l'utilisateur en cas de problème.

MODULE DE SECURITE ET D'AUTHENTIFICATION

 Gère la sécurité et l'authentification des utilisateurs.
 Vérifie les identifiants d'accès et les permissions des utilisateurs pour contrôler
l'accès aux fonctionnalités et aux données sensibles.

MODULE DE CONFIGURATION ET DE PERSONNALISATION

 Permet à l'utilisateur de configurer les paramètres du logiciel, tels que les unités de
mesure, les options de calcul et les préférences d'affichage.
 Offre des fonctionnalités de personnalisation pour adapter le logiciel aux besoins
spécifiques de l'utilisateur.

13
 VII. PROGRAMMATION ET DEVELEPPEMENT DU
LOGICIEL
// Classe principale du logiciel
public class Main {
public static void main(String[] args) {
// Création de l'interface utilisateur
UserInterface ui = new UserInterface();
ui.run();
}
}
// Interface utilisateur
public class UserInterface {
public void run() {
// Afficher l'interface utilisateur
// Récupérer les données d'entrée de l'utilisateur
// Création du modèle de structure
StructureModel structure = new StructureModel();
structure.loadFromInputData(inputData);
// Calcul des efforts sur la structure
FiniteElementAnalysis analysis = new FiniteElementAnalysis();
AnalysisResult result = analysis.calculate(structure);

// Affichage des résultats

displayResults(result);
}
// Méthode pour afficher les résultats
private void displayResults(AnalysisResult result) {
// Afficher les graphiques, les tableaux, etc. des résultats
}
}

14
// Modèle de structure
public class StructureModel {
public void loadFromInputData(InputData inputData) {
// Charger les données d'entrée et créer la structure
}
// Autres méthodes pour manipuler la structure
}
// Analyse des éléments finis
public class FiniteElementAnalysis {
public AnalysisResult calculate(StructureModel structure) {
// Effectuer les calculs des efforts sur la structure
// Retourner les résultats de l'analyse
}
}
// Classe pour les résultats de l'analyse
public class AnalysisResult {
// Attributs pour stocker les résultats des calculs
}
// Classe pour les données d'entrée
public class InputData {
// Attributs pour stocker les données d'entrée de l'utilisateur
}
import numpy as np
def solve_fem(length, num_elements, forces, supports):
# Calcul des longueurs des éléments
element_length = length / num_elements
# Création de la matrice de raideur globale
stiffness_matrix = np.zeros((num_elements+1, num_elements+1))
# Assemblage de la matrice de raideur globale
for i in range(num_elements):

15
 stiffness_matrix[i:i+2, i:i+2] += np.array([[1, -1], [-1, 1]]) / element_length
# Création du vecteur de charges globales
global_force_vector = np.zeros(num_elements+1)
# Assemblage du vecteur de charges globales
for i, force in forces:
global_force_vector[i] += force
# Application des conditions aux limites
for support in supports:
index, reaction = support
stiffness_matrix[index, :] = 0
stiffness_matrix[index, index] = 1
global_force_vector[index] = reaction
# Résolution du système d'équations
displacements = np.linalg.solve(stiffness_matrix, global_force_vector)
# Calcul des efforts dans chaque élément
element_efforts = []
for i in range(num_elements):
displacement_diff = displacements[i+1] - displacements[i]
element_effort = displacement_diff * element_length
element_efforts.append(element_effort)
return displacements, element_efforts
# Fonction pour afficher les résultats
def print_results(displacements, element_efforts):
print("Déplacements : ", displacements)
print("Efforts dans les éléments : ", element_efforts)
# Fonction principale
def main():
length = 10.0 # Longueur totale de la structure
num_elements = 5 # Nombre d'éléments
forces = [(2, 10.0), (4, -5.0)] # Charges appliquées sur les nœuds (indice, valeur)

16
 supports = [(0, 0.0), (5, 0.0)] # Conditions aux limites (indice, réaction)

# Résolution du problème à l'aide de la méthode des éléments finis

displacements, element_efforts = solve_fem(length, num_elements, forces, supports)
# Affichage des résultats
print_results(displacements, element_efforts)
if __name__ == '__main__':
main()

17
 CONCLUSION

Nous avons examiné la conception d'un logiciel de calcul des efforts sur une structure
décomposable en éléments finis à 1D, 2D et 3D. Nous avons discuté de l'architecture générale
du logiciel, de sa conception et avons fourni un programme en Java pour illustrer son
fonctionnement. Le logiciel propose une interface utilisateur pour permettre à l'utilisateur de
définir les propriétés de la structure, les charges appliquées et les options de calcul. Il comprend
également un module de prétraitement pour valider et convertir les données d'entrée, un module
d'analyse des éléments finis pour calculer les efforts sur la structure, et un module de post-
traitement pour afficher les résultats de manière compréhensible. La conception du logiciel
repose sur des principes de modularité, de séparation des responsabilités et d'extensibilité. Les
différents composants interagissent de manière coordonnée pour effectuer les calculs
nécessaires et fournir les résultats à l'utilisateur.

18