Rapport MEF Depieds Le-Goff Cuisset1

2
Projet méthode éléments finis — MI4
Polytech Montpellier — Université Montpellier
Prédiction de propagation de fissure par la

méthode éléments finis
année 2019-2020
Auteurs
William LE GOFF Encadrant
Lucas CUISSET Yann MONERIE
Lucas DEPIEDS
Résumé
Le problème considéré est la prédiction de la direction de propagation d’une fissure décentrée dans une plaque
de béton en flexion trois points. Le sujet est traité par couplage de la méthode éléments finis avec l’étude statistique
locale des trajets de fissure en milieu hétérogène. Ce rapport est focalisé sur l’utilisation de la méthode éléments finis,
et a pour objectif d’apporter une procédure d’estimation locale de la direction de propagation de la fissure au sein d’un
milieu 2D homogénéisé. Le but est la répétition de cette procédure jusqu’à l’obtention du tracé global de la fissuration
dans la structure. Une courte introduction sur les notions essentielles à maîtriser pour la compréhension de ce rapport
sera faite ainsi qu’une présentation et une justification des hypothèses cruciales pour légitimer scientifiquement la
méthode. La procédure sera présentée en cinq étapes reposant uniquement sur l’utilisation de logiciels libres pour
l’éducation. Ces cinqs étapes abordent des problèmes de remaillage, de calculs de contraintes grâce à la méthode des
éléments finis, d’imagerie et d’automatisation de la procédure. Le rapport sera également accompagné d’une fiche
technique, permettant la mise en application de la méthode pour les étudiants en 5ème année et en thèse chargés de
l’approche probabiliste du sujet.
The report concerns prediction of the direction of crack growth applied to the problem of a shifted initial crack
in a concrete slab submitted to a three-point flexion. The subject is about coupling finite element method with a
statistical approach of local path of cracks in a heterogeneous material. This report focuses on the application of
the finite element method and aims for the development of an estimation procedure of the local direction of crack
growth considering a homogenized material in two dimensions. The repetition of this procedure will provide a global
crack path through the whole structure. A short introduction to the essential notions needed for the understanding
of this report and a justification of the main hypothesis will be provided. The procedure will be introduced in five
steps, based on the utilization of free of charges software for educational meaning. Those five steps broach problems
of meshing, stresses calculation using finite element method, imagery and automatisation of the global procedure.
The report is enclosed to a technical report, allowing the application of the procedure for the two other students
working on the statistical approach.
Remerciements
Nous tenions à remercier notre tuteur de projet M. Yann Monerie, pour son aide apportée, sa pédagogie
ainsi que l’intérêt porté sur le travail que nous avons réalisé durant plusieurs mois. Merci également à lui
d’avoir toujours su se rendre disponible même en période de crise sanitaire. Merci à M. Bruno Koobus de
nous avoir guidé lorsque nous avons eu besoin d’aide sur des opérations mathématiques. Merci également à
M. Alexandre Pinlou pour son module d’enseignement « Informatique pour le calcul scientifique ». Ce dernier
nous a permis (notamment grâce à un projet) de comprendre l’intérêt du pilotage et de l’automatisation de
tâches sur des logiciels scientifiques. Pour finir merci à M. Hugo Le Goff ingénieur en génie civil de nous
avoir aidé à obtenir des informations sur l’étude des fissures dans le cadre de ses fonctions.
Table des matières
1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
2 Etude des fissures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
2.1 Recherche appliquée : application au génie civil . . . . . . . . . . . . . . . . . . . . . . . 1
2.2 Recherche fondamentale : génie mécanique . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2.2.1 Notion de triaxialité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2.2.2 Approche Cinématique et modes de propagation . . . . . . . . . . . . . . . . . . . 3
2.2.3 Bilan des méthodes existantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
3 Méthode de prédiction de propagation de fissure . . . . . . . . . . . . . . . . . . . . . . . 4
4 Modélisation du problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
4.1 Cadre d’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
4.1.1 Problème de flexion à fissure décentrée . . . . . . . . . . . . . . . . . . . . . . . . 6
4.1.2 Béton utilisé, composition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
4.2 Hypothèses : récapitulatif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
5 Méthode éléments finis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
5.1 Structure du programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
5.2 Création de la géométrie initiale via GMSH et maillage . . . . . . . . . . . . . . . . . . . 9
5.3 Calcul des contraintes via Cast3m . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
5.4 Parseur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
6 Traitement des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
6.1 Interpolation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
6.2 Détermination de la direction de propagation de fissure . . . . . . . . . . . . . . . . . . . 11
6.3 Recherche du plan de symétrie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
6.3.1 Segmentation en sous-domaines . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
6.3.2 Méthode directe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
6.3.3 Méthode par imagerie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
7 Etude locale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
8 Progression de la fissure et remaillage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
9 Bilan sur le fonctionnement du programme . . . . . . . . . . . . . . . . . . . . . . . . . . 26
10 Analyse des résultats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
10.1 Notions de déterminisme et probabilisme . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
10.2 Convergence et influence des paramètres . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
10.3 Chemins de propagation obtenus en fonction de la méthode . . . . . . . . . . . . . . . . . 31
10.3.1 Fissure décentrée à gauche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
10.3.2 Fissure centrée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
10.4 Limites et potentiels d’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
11 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
A Annexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
A.1 Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
1 Introduction 1
1 Introduction
La mécanique de la rupture est étudiée depuis le 19ème siècle suite à l’apparition d’accidents dans
de nombreux domaines industriels : l’accident du train de Versailles en 1842, les crash des premiers vols
commerciaux “Havilland Comet” en 1954 ou l’accident de la plateforme de forage Alexander L. Kielland en
1980. Ces évènements, qui ont marqué l’histoire de manière plus ou moins funeste, sont les résultats d’un
phénomène qui fait toujours l’objet de recherches aujourd’hui : la fatigue des matériaux [14] . Dans ces cas
concrets, la propagation d’une fissure par fatigue commence par la présence d’un défaut ou d’une micro-
fissure déjà existante au sein d’une pièce “maîtresse” d’un mécanisme. Suite à des sollicitations cycliques de
ces pièces, la présence de défauts entraîne une concentration de contrainte extrême et localisée provoquant
la fissuration progressive de la structure.
2 Etude des fissures
2.1 Recherche appliquée : application au génie civil

La méthode développée sera appliquée directement au béton. L’exemple de l’application au domaine du
génie civil permettra d’illustrer concrètement le problème traité. En génie civil, des solutions empiriques ont
été trouvées, permettant de limiter la propagation de défauts dans une structure. « La fissuration doit être
limitée de telle sorte qu’elle ne porte pas préjudice au bon fonctionnement ou à la durabilité de la structure
ou encore qu’elle ne rende pas son aspect inacceptable. » [1] .
Le béton est principalement utilisé pour protéger les structures métalliques de l’oxydation[2]. Ainsi on
classifie certaines fissures comme “non préjudiciables” dès lors qu’elles ne mettent pas en péril la tenue mé-
canique de l’armement métallique d’une structure. L’origine des fissures a également largement été étudiée :
pathologies d’action de l’H2 S, pathologies de corrosion des armatures, déformations de la structure, retrait
de dessiccation, retrait endogène, réaction de gonflement interne, fluage.
Il existe également des classifications de fissures en fonction de leur apparence externe[3] :

- Microfissure : ouverture très fine, tracé irrégulier et largeur inférieure à 0,2 mm
- Faïençage : réseau de microfissures sur la couche superficielle du béton
- Fissure : ouverture linéaire de largeur comprise entre 0,2 et 2 mm
- Fracture : ouverture de largeur supérieure à 2 mm
Plusieurs cas sont illustrés "Figure 1".
Fig. 1: Faiençage - Fissure - Fracture
Pour traiter les fissures ou leurs conséquences, il est important de pouvoir prédire la propagation des
fissures.
2 Etude des fissures 2
2.2 Recherche fondamentale : génie mécanique

2.2.1 Notion de triaxialité
Le phénomène de fatigue apparaît lorsqu’un défaut existe au sein d’une structure, ce qui a toujours
lieu. Ce n’est pas la résistance du matériau qui décroît naturellement avec le temps, mais les contraintes
qui augmentent autour d’un défaut [10]. Dans ces zones, les contraintes sont localement bien supérieures
à la résistance du matériau. Cette dépendance entre contrainte globale et concentration locale est illustrée
"Figure 2" :
Fig. 2: Contrainte principale σI à déplacement imposé de 1mm sur la face droite dans la direction x,
sans et avec imperfection
La notion sous-jacente à ce que l’on observe est la triaxialité des contraintes [12]. Complexe à définir,
la triaxialité englobe la notion de géométrie, contrainte normale et contrainte de cisaillement. Plus la géo-
métrie est abrupte, plus les contraintes normales et de cisaillement ont un fort gradient au voisinage de
cette géométrie, et plus la triaxialité est forte. Un même matériau n’aura donc pas la même réponse à un
chargement lointain en fonction de sa géométrie comme illustré "Figure 3".
Fig. 3: Lien entre triaxialité, déformation et contrainte à rupture
L’une des hypothèses majeures de la méthode développée dans ce rapport est la propagation stable de
2 Etude des fissures 3
la fissure. Elle permet dans le cadre de la mécanique de la rupture linéaire [9], d’établir des critères de
bifurcation de la fissure définis par des facteurs de concentration de contraintes K. Elle est applicable dès
lors qu’on considère la déformation plastique comme négligeable. Dans le cas contraire, d’autres méthodes
établies sur le taux de restitution de l’énergie G ou l’intégrale de Rice J peuvent être utilisées [4]. Cette
distinction est vulgairement appelée rupture fragile ou ductile.
2.2.2 Approche Cinématique et modes de propagation

Deux classifications de méthodes existent, elles reposent sur deux approches théoriques du phénomène
de rupture : l’approche cinématique avec le facteur K, et l’approche énergétique avec le taux G et l’inté-
grale J. Comme indiqué précédemment, la méthode développée se base sur une approche cinématique de
la propagation de fissure. On y distingue trois modes de propagation [13], et un mode mixte les regroupant,
présentés "Figure 4".
Fig. 4: Modes de propagation de fissure - Approche cinématique
Ces approches sont dites cinématiques car elles ne reposent pas sur l’état de contrainte au fond de fissure,
infini. Un résultat analytiquement démontré par l’étude des contraintes aux abords d’un défaut elliptique q est
présenté "Figure 5". La contrainte maximale dans ce cas est donnée par l’équation σmax = σ∞ (1+2 aρ ).
Lorsque ρ tend vers zéro, la contrainte σmax aux bords de l’ellipse tend vers l’infini.
Néanmoins, les différents modes décrivent le déplacement des lèvres de la fissure. En mode I par exemple,
la fissure soumise à une traction simple se propagera perpendiculairement à la sollicitation.
Fig. 5: Défaut elliptique au sein d’une structure solicitée en mode I

3 Méthode de prédiction de propagation de fissure 4
2.2.3 Bilan des méthodes existantes

Les méthodes qui découlent de cette approche cinématique nécessitent l’établissement de modèles, eux-
mêmes définis par la connaissance fine de la géométrie de la pointe de la fissure [11]. Elles sont donc
difficilement applicables à des matériaux hétérogènes et anisotropes.
De plus, le caractère infini des contraintes en pointe de fissure n’est absolument pas physique. C’est
pourquoi ce sera un des facteurs limitant lors de l’application de la méthode développée dans ce rapport.
Dans les faits, les contraintes épousent l’allure décrite sur la "Figure 6" . L’évolution de la contrainte
aux abords de la pointe de fissure est due aux phénomènes de plasticité, d’endommagement et d’autres
qui, par la nucléation de cavités et par la libération d’énergie (calorifique, changement de phase, etc) font
réduire la concentration de contrainte [12].
Fig. 6: Contrainte σθ en fonction de la distance à la pointe de fissure
Néanmoins, les méthodes qui simulent ces phénomènes sont coûteuses en temps de calcul [8]. Il faut
plusieurs semaines pour estimer le chemin de propagation d’une fissure dans une structure de quelques
mètres.
La principale motivation à la mise en place d’une nouvelle méthode probabiliste est donc l’économie de
temps de calcul et son application sans connaissance préalable de la géométrie du fond de fissure. Ce sont
deux facteurs qui font l’intérêt de la technique.
3 Méthode de prédiction de propagation de fissure
Les méthodes qui seront présentées couplent une approche éléments finis et l’étude statistique locale
des trajets de fissure en milieu hétérogène.
Les données nécessaires pour l’application de la méthode sont :

- La géométrie globale de la structure.
- La géométrie à une échelle inférieure aux inclusions du matériau considéré.
- Les propriétés du matériau considéré.
3 Méthode de prédiction de propagation de fissure 5
- Les chargements extérieurs appliqués à la structure.
La première étape est la détermination de la direction de propagation de fissure.

Dans le cas du problème "Figure 7", l’approche cinématique d’Irwin indique qu’au sein d’un matériau
isotrope, la direction de propagation de fissure est perpendiculaire à la direction d’application des forces aux
limites de la structure (mode I).
Dans le cadre d’une méthode de simulation à critère énergétique

 complète,
 on obtiendrait un trajet
σI 0 0
macroscopiquement droit, comme celui "Figure 7", avec σ∞ = 0  0 0
0 0 0
Fig. 7: Propagation d’une fissure en mode I pur
Une des hypothèses majeures de la méthode développée est donc la propagation globalement rectiligne
perpendiculairement à un chargement en traction.
Cette hypothèse peut sembler limitée. En effet, dans le cadre d’une approche cinématique, les modes
II et III au sens d’Irwin pourraient avoir un impact sur la direction globale de propagation de la fissure.
Néanmoins, la théorie cinématique repose sur la connaissance des facteurs de concentration de contrainte
K. Il existe un facteur par mode de propagation. Pour qu’une fissure se propage selon une direction définie
par l’un des modes, il faut que la concentration de contrainte en pointe de fissure dépasse un seuil noté K c .
On peut observer dans le cas du béton et de nombreux autres matériaux que KIc << KII c et K c < K c .
I III
Dans la pratique, une propagation presque toujours orientée selon le mode I serait observée, ce qui permet
de soutenir cette hypothèse.
Ce résultat est particulièrement cohérent vis-à-vis des connaissances actuelles relatives au béton. Ce ma-
tériau a une forte tenue mécanique en compression mais une sensibilité accrue à la traction (caractéristique
du Mode I). C’est d’ailleurs pour empêcher la sollicitation du béton en mode I qu’a été inventé en génie
civil le béton précontraint.
L’objectif de la méthode développée dans ce rapport est de déterminer l’orientation de la direction de

propagation, perpendiculaire au déplacement des lèvres de la fissure en mode I, dans des situations géomé-
triques où la cinématique d’Irwin n’offre pas de solution analytique. Cette direction de propagation n’est pas
nécessairement droite dans toute la structure considérée, il sera donc important de segmenter la structure
étudiée en sous-domaines.
Une fois la direction déterminée, l’étude locale des trajets de fissure repose sur une base de données
4 Modélisation du problème 6
regroupant des simulations semblables à la "Figure 7". En effet, grâce à l’utilisation de chaînes de Markov
et d’une base de données conséquente, la méthode est capable au sein d’un maillage d’estimer la probabilité
que la fissure rejoigne un noeud pour chacun des noeuds “candidats”.
Ces points candidats sont déterminés de la façon décrite "Figure 8"
Fig. 8: Méthode de détermination des noeuds candidats
Une fois l’ensemble des candidats déterminés, l’algorithme établit la probabilité que la fissure rejoigne
un noeud en fonction de sa distance et de la bifurcation nécessaire pour le rejoindre.
Cette explication de l’étude locale statistique des trajets de fissure est extrêmement simplifiée car elle
n’est pas l’objet de ce rapport.
4 Modélisation du problème
4.1 Cadre d’application

4.1.1 Problème de flexion à fissure décentrée
La simulation est étudiée dans un premier temps dans le cas d’un problème de flexion trois points à
fissure décentrée comme présenté "Figure 9".
4 Modélisation du problème 7
Fig. 9: Problème flexion trois points à fissure décentrée
Cette modélisation du problème offre deux avantages majeurs :

- L’intuition mécanique, liée à l’observation de cas concrets de fissuration, permet de supposer que la
fissure devrait globalement suivre un trajet reliant l’amorce de fissure initiale au point où le déplacement est
imposé.
- La possibilité de faire varier l’origine de la fissure initiale en gardant les mêmes hypothèses. Il sera ainsi
possible de s’assurer que la méthode développée n’est pas simplement la solution d’un cas particulier, mais
applicable à différents cas.
4.1.2 Béton utilisé, composition

Il existe plusieurs types de bétons. Leurs caractéristiques mécaniques sont déterminées par leur com-
position. Classiquement, un béton est composé de ciment, de granulats, d’eau et éventuellement de divers
adjuvants [6]. Le béton considéré dans ce rapport sera modélisé composé à 50 % d’une matrice de module
d’Young Em et coefficient de Poisson νm et à 50 % d’inclusions de module d’Young EI et de coefficient
de Poisson νI . La taille caractéristique des inclusions est de 1 cm. Il sera également supposé que EI >> Em .
Pour une longueur de propagation de 10 cm, une fissure rencontrera donc en moyenne une dizaine
d’inclusions, comme illustré "Figure 10".
Fig. 10: Composition du matériau simulé : Béton
A l’échelle de quelques grains, la fissure se propage en mode I en contournant les granulats. En effet, le
module d’Young des granulats est plus élevé que celui de la matrice. Le principe de minimisation de l’énergie
5 Méthode éléments finis 8
impose donc que la fissure ne traversera pas un granulat mais aura tendance à le contourner.
4.2 Hypothèses : récapitulatif

La méthode développée repose sur plusieurs hypothèses majeures.
Tout d’abord, le calcul est réalisé dans le cadre de la mécanique élastique linéaire de la rupture, sous
hypothèse des petites perturbations. De ce fait la méthode ne pourra pas s’appuyer sur les contraintes
calculées dans un rayon proche du fond de fissure (zone de plasticité étendue).
Ensuite, le matériau simulé est homogénéisé. L’homogénéisation par la méthode des volumes élémentaires
représentatifs (VER) est habituellement requise dans ce genre de simulation [7]. Plus le degré de non linéarité
de la propriété étudiée est grand, plus la taille du VER ou le nombre de réalisations nécessaires sont grands.
Dans l’hypothèse où il faudrait homogénéiser un matériau comme le béton pour un phénomène non linéaire
comme la rupture, les moyens à notre disposition ne seraient pas suffisants.
Néanmoins, la méthode développée dans ce rapport n’a pas pour objet l’étude de la propriété de fissura-
tion. En effet, c’est le modèle d’étude statistique de la propagation qui traite de cette propriété localement.
En revanche, on étudie les propriétés élastiques homogènes isotropes du matériau, il faut donc homogé-
néiser le milieu. Par soucis de temps, et la notion de VER n’étant pas le sujet principal du projet, il a été
choisi de considérer un matériau homogène isotrope avec les caractéristiques suivantes : Module d’Young
E=30 GPA ; Coefficient de Poisson ν= 0,22.
Enfin la dernière hypothèse est la propagation en Mode I de la fissure. Cette hypothèse implique de
rester attentif aux déplacements aux lèvres de la fissure.
5 Méthode éléments finis
5.1 Structure du programme

Les connaissances théoriques accumulées ainsi que la modélisation du problème et des hypothèses ont
permis d’avoir une vision globale du travail à effectuer. Une stratégie et l’algorithme associé ont été mis en
place. Ce dernier est décrit "Figure 11" .
Fig. 11: Structure globale du programme
Sur ce schéma, les grandes étapes sont visibles. Notamment à la première ligne, le choix de la méthode
utilisée pour déterminer la direction de propagation de la fissure. En effet plusieurs méthodes de détermination
ont été mises en place, et seront présentées dans ce rapport. Un choix de méthode doit donc être fait au
début de l’algorithme. Par la suite des paramètres d’entrée peuvent également être choisis (géométrie,
maillage, etc). Les autres étapes de l’algorithme seront détaillées dans les parties suivantes.
5.2 Création de la géométrie initiale via GMSH et maillage

Une fois le problème correctement formulé, sa géométrie peut être définie. Pour effectuer des calculs aux
éléments finis, la géométrie du problème aurait pu être directement générée via le logiciel Cast3m. Toutefois,
le choix d’utiliser GMSH a été fait. En effet GMSH fournit généralement une qualité de maillage appréciable,
et est réputé pour son optimisation. Son ergonomie rend ce logiciel facile d’utilisation et de compréhension.
Le programme étant écrit en langage Python, la création de la géométrie initiale sur GMSH est donc
pilotée par Python. Un des modules développés contient une fonction d’initialisation qui permet de créer un
fichier d’extension .geo contenant la géométrie du problème.
Les paramètres d’entrée à fournir sont ceux de la géométrie du problème : largeur, hauteur, point
d’application du chargement, position de l’amorce de fissure, largeur de la fissure, la densité de maillage
au niveau de la fissure et du point d’application du déplacement, la densité de maillage dans le reste du bloc.
Cette multitude de paramètres permet d’adapter le problème traité très rapidement dans le cas où il
serait question de traiter d’autres configurations.
A l’aide du module Python "Subprocess", le maillage de la géométrie du fichier .geo est réalisé, un
fichier d’extension .unv est créé contenant le maillage de la structure. Ce dernier peut être lu et exploité par
Cast3m.
5.3 Calcul des contraintes via Cast3m

Le problème de flexion trois points à fissure décentrée est simulé par un calculateur éléments finis réputé
pour sa fiabilité et son efficacité : “Cast3m”. C’est un outil développé par le CEA.
La résolution numérique s’effectue en plusieurs étapes :
- La première étape est la lecture du fichier au format .unv, généré par le logiciel GMSH et contenant
des éléments tétraédriques.
- La seconde étape est la définition des lois de comportement et des hypothèses. Il a précédemment été
choisi d’utiliser l’approche cinématique d’Irwin. De plus la direction principale de propagation de fissure a
vocation à être déterminée à une distance approximative de 10 centimètres de la pointe de fissure (cette
notion sera reprise plus loin). Enfin, les propriétés du béton permettent de faire l’hypothèse d’une zone de
plasticité en pointe de fissure très petite. C’est pourquoi il a été décidé de configurer le programme en
mécanique élastique linéaire. De ce fait, on a l’équation σ =⊂: ε.
L’hypothèse des déformations planes a également été configurée. Elle s’applique à une structure dont les
dimensions longitudinales seraient grandes par rapport aux dimensions du plan de coupe. Ce qui correspond
au cas d’une dalle de béton allongée. Cette hypothèse correspond également à l’application d’efforts dans
le plan de coupe, particulièrement pertinente dans le cas d’un problème de flexion trois points à fissure
décentrée. Les contraintes et les déplacements seront donc de la forme suivante :
   
ε11 ε12 0 λtr(ε) + 2µ · ε11 2µ · ε12 0
ε = ε12 ε22 0 σ= 2µ · ε12 λtr(ε) + 2µ · ε22 0 
0 0 0 0 0 λtr(ε)
- La troisième étape est l’application des conditions aux limites propres au problème considéré. Le dépla-
cement des points d’appui a donc été bloqué. Un déplacement imposé a également été configuré centré sur
le dessus du bloc de béton. Il est égal à 1 mm dans la direction verticale. Le choix d’imposer un déplacement
et non une force est crucial pour le respect de l’hypothèse de propagation stable de la fissure.
- La quatrième étape est la résolution de l’équation : div(σ) + F = 0 , permettant de calculer le champ

de déplacements et de contraintes dans l’ensemble des mailles du domaine. Cette étape est souvent longue,
car elle nécessite l’inversion de la matrice de rigidité du domaine. La taille de cette matrice est définie par
le nombre de mailles dans le domaine, le type de maillage utilisé (trièdre, quadrangle, etc..), et le degré
d’interpolation souhaité. Une résolution linéaire de trièdre a été configurée, parfaitement adéquate pour la
résolution d’un problème en élasticité linéaire.
- La cinquième étape est l’utilisation d’un opérateur de diagonalisation. Cet opérateur permet le calcul
des valeurs propres de chacun des tenseurs des contraintes des mailles du domaine. Il permet donc de calculer
la contrainte σI , première valeur propre du tenseur des contraintes. Pour rappel, ces contraintes sont celles
utilisées comme critère pour établir la direction de propagation. En effet, il a été émis l’hypothèse d’une
propagation de fissure en mode
 I comme  présenté "Figure 4", cela signifie l’application d’une contrainte
σI 0 0
lointaine de la forme : σ =  0 0 0.
0 0 0
Par l’étude des valeurs propres des tenseurs de contraintes, la méthode permettra d’établir la direction
où les contraintes sont les plus importantes et de ce fait permettra d’établir la direction de propagation.
- Enfin, la dernière étape est l’utilisation d’un outil permettant l’exploitation des résultats obtenus avec
d’autres logiciels. Cette étape est indispensable car Cast3m ne permet pas les traitements à suivre. Il a
été choisi deux formats distincts : tout d’abord le format "vtk" permettant le traitement des données par
imagerie grâce à l’outil Paraview, et le format .inp dont l’interprétation nécessite la création d’un parseur
sous Python [5].
5.4 Parseur
L’objectif de ce parseur est l’interprétation du fichier au format .inp sorti par Cast3m et regroupant les
calculs de contraintes et la géométrie de la structure. L’organisation de ce fichier est présentée "Figure 12".
Le parseur parcourt donc ce fichier, et par la succession d’étapes, ne garde que les deux données utilisées :
les positions des noeuds de chacune des mailles et la valeur propre de contrainte maximale associée : σI .
6 Traitement des données 11
Fig. 12: Contenu du fichier au format .inp
La méthode est également déjà codée pour calculer les contraintes de Von Mises équivalentes, ainsi
que toutes les autres valeurs de contraintes dans le cas où la méthode viendrait à changer de critère de
propagation.
6 Traitement des données
6.1 Interpolation
Les données extraites de Cast3m sont les tenseurs des contraintes diagonalisés. Ces tenseurs sont ex-
primés en chaque point de Gauss, centres des mailles triangulaires. Dans l’objectif de mettre en application
les méthodes présentées par la suite, il a été proposé d’interpoler les valeurs propres des contraintes en tout
point de l’espace afin d’établir un champ de contrainte continu.
Après l’étude de plusieurs techniques d’interpolation et la mise en place de certaines sur Matlab, il a
été décidé que la validité scientifique de ces interpolations pouvait être remise en question. Les tenseurs des
contraintes considérés par la suite seront ceux calculés par Cast3m aux points de Gauss, sans interpolation.
6.2 Détermination de la direction de propagation de fissure

Grâce aux calculs Cast3m réalisés sur la structure d’étude, les contraintes principales dans la plaque
de béton sont récupérées au format .inp. Ce fichier interprétable grâce au parseur, fournit les valeurs des
contraintes principales ainsi que l’orientation des vecteurs associés sous forme de cosinus directeurs. Il est
ainsi possible de récupérer l’angle d’inclinaison de ces vecteurs en chaque point de Gauss.
C’est à partir de ces données qu’il a fallu réfléchir à différentes méthodes pour déterminer la direction
de propagation de fissure.
Les contraintes principales récupérées sont triées dans un ordre décroissant, avec σI la plus grande. C’est
la seule contrainte qui sera considérée pour calculer la direction de propagation, comme il a été expliqué
précédemment.
Dans le cadre de cette étude, différentes méthodes ont été proposées et testées.
Première idée :
Le principe est de projeter dans la base cartésienne 2D (~x, ~y ), le vecteur propre associé à la contrainte
σI . Cette idée donne en chaque point de Gauss une valeur de contrainte dans la direction ~x et dans la
direction ~y comme présenté figure[n]
A partir de cette idée plusieurs variantes ont été considérées. La première consistait à moyenner les com-
posantes sur x et y de tous les vecteurs aux n points de Gauss, situés dans le sous-domaine étudié. Cela don-
nerait un vecteur contrainte résultant ~r qui permettrait d’en déduire la direction de propagation (perpendicu-
1 P
laire à ce vecteur). Cette méthode donnerait une équation de la forme : ~r = n n σIn ·(cos(θn )~x +sin(θn )~y )
Plusieurs variantes ont été testées en restreignant le champ d’observation du sous-domaine d’abord à
un demi-cercle centré sur le fond de fissure et dirigé vers les y supérieurs (méthode I) puis à un second
demi-cercle de même centre mais cette fois dirigé vers le chargement (méthode II).
Les deux idées sont illustrées "Figure 13" sur cette figure on distingue la méthode I en vert et II en
rouge ainsi que la projection dans la base cartésienne d’un vecteur de contrainte principale.
Fig. 13: Premières idées illustrées
La limite de ces méthodes est que l’on a supposé que l’on pouvait sommer et moyenner les valeurs propres
du tenseur des contraintes et les vecteurs propres associés de façon linéaire. Des outils mathématiques ont
été appliqués sans prendre en compte le sens physique de la démarche.
6.3 Recherche du plan de symétrie

Il a été vu précédemment que la fissure se propage en mode I. Pour ce mode, l’intérêt est porté
uniquement à la contrainte principale σI .
Les lignes d’iso-contraintes σI forment des courbes en forme “d’ailes de papillons”. Les creux de ces
papillons sont les points les plus contraints à proximité du fond de fissure. C’est donc dans la direction de
ces creux, que le facteur de contrainte critique K c sera atteint en premier et que la fissure se propagera.
La "Figure 14" représente très nettement la forme décrite.

Dans le but de déterminer la direction de propagation de fissure, les parties suivantes présenteront
différentes méthodes afin de déterminer l’angle entre l’horizontale et la droite reliant le fond de fissure aux
creux des iso-contraintes.
Fig. 14: Forme d’ailes de papillon observées en pointe de fissure
6.3.1 Segmentation en sous-domaines

Dans l’étude menée, le choix a été fait de diviser le domaine d’étude global (la plaque en béton) sur sa
hauteur en sous-domaines de travail. Ce choix est en parfait accord avec l’approche probabiliste. Il a fallu
choisir une taille de sous-domaine et par conséquent un nombre pour décomposer le domaine d’étude. Le
choix a été fait de la façon suivante.
Une plaque de béton de hauteur 1 m est étudiée. Une taille moyenne de granulat de l’ordre du centimètre
et une alternance granulat matrice de 50% a été estimée, soit 1 cm de granulat pour 1 cm de matrice. Il a
été décidé de garder dans la zone d’étude une dizaine de granulats sur le chemin de la fissure ce qui corres-
pondrait à un sous-domaine d’une vingtaine de centimètres de hauteur. Il a également été choisi de centrer
le fond de fissure, donc de travailler avec une pré-fissure de 10 cm pour chaque sous-domaine considéré.
Après avoir commencé à travailler avec des sous-domaines rectangulaires de hauteur 20 cm, il a été
finalement décidé de travailler en fonction d’un rayon de propagation et donc d’étudier des quarts de cercle.
Cette modification paraît plus juste physiquement puisqu’elle ne privilégie aucune direction de propagation.
En effet, la fissure sera propagée selon la direction obtenue sur une longueur de 10 cm.
La division de la plaque en sous-domaines circulaires est illustrée "Figure 15".

Fig. 15: Schématisation des sous-domaines d’observation
Les méthodes de détermination de direction de propagation qui seront présentées par la suite, s’appli-
queront à chaque sous-domaine d’étude.
6.3.2 Méthode directe

Il a été défini précédemment que la recherche du plan de symétrie serait réalisée grâce à la détection
des iso-valeurs de contraintes σI .
La méthode directe a pour objectif la détermination de ce plan de symétrie sans avoir recours à un
logiciel permettant l’imagerie des iso-contraintes. Elle exploite le fichier au format .inp exporté de Cast3m,
interprété et stocké dans la mémoire vive grâce au parseur développé précédemment.
Elle a donc à disposition une série de listes Python comprenant les coordonnées des noeuds du maillage,
les mailles ainsi que les trois noeuds qui les délimitent et les valeurs propres du tenseur des contraintes de
chacune des mailles exprimé aux points de Gauss.
La première étape de la méthode directe est donc naturellement le réagencement de ces informations. Les
coordonnées des points de Gauss de chacune des mailles sont donc déterminées comme indiqué "Figure 16"
Fig. 16: Position du point de Gauss au sein d’un trièdre
Les valeurs propres des tenseurs des contraintes sont ensuite attribuées au point de Gauss correspondant.
La méthode sélectionne une liste de coordonnées et des valeurs propres du tenseur des contraintes en
chacun de ces points.
Il a été présenté "Figure 4" que la propagation de fissure en mode I est caractérisée par une contrainte
σI positive. Cela correspond à une sollicitation en traction. Les points de Gauss présentant une valeur propre
σI négative sont donc écartés. En effet, la fissure ne peut se propager dans un milieu en compression.
Une zone d’étude circulaire est ensuite définie, centrée au fond de fissure d’un rayon de 10 centimètres,
correspondant à la distance parcourue par une fissure au cours d’une itération. Les points de Gauss en dehors
de cette zone sont alors écartés. Les points de Gauss à moins d’un millimètre de la pointe de fissure sont
également écartés puisqu’ils se trouvent potentiellement dans une zone où la déformation plastique n’est
pas négligeable. On obtient donc la zone d’étude présentée "Figure 17".
Fig. 17: Directe - Sous-domaine d’étude et détermination du creux, étape 1
Afin de faire apparaître la forme d’ailes de papillon, propre à la propagation en mode I, il faut “tracer”
des lignes d’iso-contraintes. Par définition, il existe une infinité de lignes d’iso-contraintes, des seuils sont
donc définis pour traiter les valeurs de contrainte σI .
Cette étape n’est pas triviale puisqu’elle nécessite de définir les seuils d’une manière particulière. En
effet, il est possible de classer les points de Gauss sur une échelle linéaire de seuils.
Néanmoins, la mécanique linéaire de la rupture a établi que les contraintes aux alentours de la pointe
1
de fissure évoluent en √2π·r .
Classer les points de Gauss selon une échelle linéaire pose donc problème puisque les seuils les plus forts
seront composés de moins de points de Gauss que les seuils les plus faibles. Il a alors été décidé de générer
1
des iso-contraintes à intervalles réguliers. Pour cela, une fonction du type r = 2π·σ 2 a été utilisée, variant
du rayon minimal au rayon maximal du sous-domaine.
La façon la plus simple pour détecter le plan de symétrie est alors de chercher le point de Gauss le plus
proche de la pointe de fissure pour chacun de ces seuils. Pour cela, il suffit de parcourir tous les points se
trouvant dans un quart de cercle dont l’origine est la pointe de fissure. Ce quart est dirigé vers le point
d’application du déplacement comme présenté "Figure 18".
Fig. 18: Directe - Sous-domaine d’étude et détermination du creux, étape 2
Le programme a alors sélectionné une série de points de Gauss correspondant aux creux des courbes
d’iso-contraintes. Il suffira alors de calculer les angles entre l’horizontale et les droites passant par la pointe
de fissure et les points de Gauss sélectionnés.
La détermination de la direction de propagation n’est cependant pas terminée. En effet, la méthode

utilise un champ discret de points. La précision des angles obtenus sera donc conditionnée par la qualité du
maillage utilisé. De plus, cela pose la question de savoir quel angle choisir parmi ceux calculés.
Il a été proposé deux méthodes dont les résultats seront discutés ci-dessous. La première propose de
moyenner les angles dans un rayon compris entre 4,5 et 5,5 centimètres. La seconde propose de moyenner
les angles calculés dans un rayon compris entre 8 et 10 centimètres.
La fiabilité du modèle devra nécessairement être confirmée par une comparaison avec d’autres résultats
expérimentaux (simulations complètes, essais de traction sur éprouvette, etc. . .).
6.3.3 Méthode par imagerie

A partir des calculs sur la structure d’étude réalisés par Cast3m, il est possible de récupérer les courbes
d’iso-contraintes. En parallèle de la méthode directe évoquée précédemment, il a été réalisé une méthode par
imagerie. Ces deux méthodes permettent de comparer les résultats obtenus et renforcent donc leur fiabilité.
Fig. 19: Zone délimitant le voisinage d’une pointe de fissure
Le champ de contrainte évolue en 1r proche du fond de fissure, dans une zone dite de plasticité confinée.
Ce sont les zones notées 1 et 2 sur le schéma "Figure 19". Dans cette zone plastique, les contraintes
tendent vers l’infini et par conséquent ne sont pas exploitables. Par définition, c’est une zone de plasticité
dans laquelle travailler en élasticité linéaire n’aurait pas de sens physique. Il faut donc traiter les contraintes
pour un rayon supérieur à cette distance, comme il a été expliqué précédemment.
Le principe de la méthode de détermination de la direction de propagation est de la définir par sous-
domaines. Il est donc logique pour traiter la propagation dans un arc de cercle de rayon 10 cm, de ne pas
regarder les contraintes au-delà de cette zone.
Dans la méthode par imagerie, les résultats sont traités visuellement grâce à des algorithmes s’appuyant
essentiellement sur du traitement d’image, réalisés en python avec les modules adaptés.
A partir du code Python, des difficultés ont été rencontrées pour travailler avec des images d’iso-
contraintes satisfaisantes, pour les échelles de couleur, la qualité, le temps de calculs etc.
Après avoir essayé plusieurs outils, le logiciel ParaView a été choisi comme support de travail. En effet il
propose un grand nombre d’outils permettant d’obtenir des visuels plus esthétiques, et plus ciblés. Il possède
également son propre interpréteur Python : pvpython. Le pilotage avec python du logiciel ParaView est donc
aisé. Grâce à ce logiciel, il a été possible de manipuler et d’obtenir les images voulues.
La "Figure 20" présente une image obtenue avec ParaView qui sera traitée par les méthodes d’imagerie.
Fig. 20: Imagerie des iso-contraintes σI
Pour obtenir cette image du fond de fissure avec les iso-valeurs de contraintes formant les papillons
visibles sur l’image, il a fallu piloter ParaView depuis Python. Le logiciel ParaView offre la possibilité d’écrire
des macro en langage Python. Ces macros permettent d’enregistrer sous forme de script les actions réalisées
sur ParaView. Dans le cadre de la méthode par imagerie, une macro type a été créée. Cette macro contient
les actions suivantes :
- Ouverture du fichier d’extension .vtu lisible par ParaView permettant notamment au logiciel d’afficher
le champ des contraintes principales.
- Traitement d’image, les couleurs sont ajustées afin d’obtenir un dégradé satisfaisant pour être exploité
plus tard.
- Un screenshot est effectué centré sur le fond de fissure.
- La résolution d’image est définie.
Une fois que cette macro type est créée, il est possible de la modifier facilement depuis Python pour
adapter notamment le centrage sur le fond de fissure. Cette macro est ensuite exécutée dans l’interpréteur
Python de ParaView grâce au module subprocess de Python. Le choix de procéder ainsi a été fait car
l’importation des modules Python propres à ParaView ou l’ajout d’un path dans l’environnement de variables
d’un OS Windows ne fonctionnait pas correctement.
C’est donc grâce à cette macro type et au pilotage de ParaView qu’il est possible d’obtenir des images
exploitables.
Le but de l’analyse d’image, comme les autres méthodes déjà énoncées est d’obtenir la direction princi-
pale de propagation de fissure.
Pour cela la méthode proposée était de récupérer l’image, la convertir en niveaux de gris, y appliquer
un lissage, puis la binariser. L’image est binarisée selon un seuil choisi. Tous les pixels aux valeurs de gris
supérieures à ce seuil sont convertis en pixels noirs et de la même façon, les pixels aux valeurs inférieures
sont passés en blanc. Le résultat obtenu est une image noire avec une « tâche » blanche partant du fond
de fissure et suivant la courbe d’iso-contrainte, formant deux ailes de papillon.
Suite à cela des algorithmes de détection des contours ont été mis en place afin de détecter les bords de
la tâche. La position du creux du papillon nous permet de déterminer l’angle correspondant à la direction
de propagation.
Pour une tâche donnée (une valeur de seuillage imposée) il est possible de récupérer les coordonnées
de ce point. En regardant seulement les points de coordonnées supérieurs en x et en y au fond de fissure
(cadran supérieur droit), le creux est défini par le point le plus proche du fond de fissure appartenant au
contour. Il permet de trouver une direction principale.
L’algorithme a été simplifié par la suite. L’image traitée est récupérée en niveaux de gris directement,
elle est ensuite binarisée et le creux est défini par le pixel noir le plus proche du fond de fissure. On obtient
l’angle α que fait l’horizontale avec la droite passant par le fond de fissure et le creux du papillon .
La figure "Figure 21 (a)" correspond à une image renvoyée par Python pour la méthode de détection
des contours. On distingue sur cette image la tâche en forme de papillon en blanc, les contours en bleu,
les points du contour appartenant au cadran supérieur droit en croix rouges, le fond de fissure et le creux
en points verts et la direction de propagation de fissure en pointillés verts. La "Figure 5 (b)" représente
la méthode simplifiée expliquée précédemment, on remarque que l’image est simplement binarisée et on
obtient la direction principale de la même façon.
Fig. 21: Imagerie - Détection du creux : (a) méthode des contours ; (b) méthode simplifiée
Il a été constaté que les creux des iso-contraintes ne sont pas alignés, il y a un décalage entre chaque
courbe. Pour cette raison, il n’est pas précis de tester qu’une seule valeur seuil. L’angle varie en fonction du
seuil choisi.
Plusieurs méthodes ont été considérées. Il a été envisagé de définir des valeurs seuil le long d’une droite
par exemple. Il a également été proposé de considérer tous les seuils d’un carré autour du fond de fissure.
Pour choisir les seuils le long d’une droite, le nombre d’iso-contraintes dépend fortement de l’angle de
la droite considérée et est donc peu précis. De la même façon, la seconde proposition a été écartée. Regar-
der dans un carré aurait peu de sens car nous travaillons sur des sous-domaines circulaires (des quarts de
cercles), il est donc plus intuitif que la zone dépende d’un rayon et non d’une longueur fixe sur x et y.
Finalement la solution suivante a été retenue :

Il a été vu précédemment qu’il ne fallait pas considérer les iso-valeurs trop proches du fond de fissure ni
les iso trop éloignées pour avoir une bonne approximation. De ce fait, la zone de test a été réduite aux points
de coordonnées supérieures au quart de cercle centré sur le fond de fissure de rayon 7 cm et inférieures au
cercle de rayon 10 cm, "Figure 22". Toutes les valeurs de niveaux de gris dans cette zone sont testées
comme seuils afin de parcourir chaque iso-contrainte.
Fig. 22: Imagerie - Domaine d’observation
Il a fallu rajouter une condition excluant certaines valeurs. Les exemples suivants sont illustrés "Fi-
gure 23". Un bout d’aile de papillon pourrait apparaître dans la zone d’étude sans que le creux y soit pour
autant. Dans ce cas l’algorithme aurait récupéré une valeur correspondant à un point quelconque de l’aile
ce qui fausserait les calculs. C’est le cas de la couleur jaune, on voit que le creux récupéré correspond bien
au point le plus proche mais pas au creux du papillon traité. Dans la "Figure 23" toutes les possibilités
sont présentées. L’iso verte est plus loin que la zone d’observation, elle ne sera donc pas considérée, c’est
également le cas de l’iso orange qui est trop proche du fond de fissure. En revanche la courbe rouge corres-
pond à une bonne valeur de seuil pour laquelle le creux sera repéré et l’angle calculé.
Fig. 23: Imagerie - Valeurs de seuils testés
Grâce à cette méthode, l’algorithme obtient en moyenne 3 valeurs d’angles qui sont moyennées afin
d’obtenir la direction de propagation de fissure. L’algorithme est ensuite relancé à chaque itération pour
faire propager la fissure. La "Figure 24" montre le résultat de la méthode par imagerie pour une itération.
7 Etude locale 22
On peut y distinguer les différentes iso-contraintes, les creux des papillons et l’angle moyen obtenu.
Fig. 24: Imagerie - Résultat
7 Etude locale
Dans l’idéal, la méthode aurait dû être testée avec l’utilisation de l’algorithme de prédiction du trajet
de fissure présenté avant. Cependant, cet algorithme est encore en développement. Il a donc été décidé de
développer un Toy-Model simulant le comportement de l’algorithme de prédiction afin de pouvoir approuver
la méthode développée dans ce rapport.
Cette étude locale basée sur des notions statistiques et probabilistes est le thème de recherche d’une
étudiante en thèse.
Un premier Toy-Model a été développé, son principe était de générer de façon aléatoire le parcours de
la fissure. Il y était défini un nombre de points à générer ainsi que le point de départ et le point d’arrivée.
Ces points, compris dans une bande reliant le départ à l’arrivée, étaient ensuite numérotés en fonction de
leur distance au point de départ, comme décrit "Figure 25"
7 Etude locale 23
Fig. 25: Toy Model - Version 1
Le problème qui s’est par la suite révélé avec cette méthode est l’apparition d’angles extrêmement petits,
qui nécessitent d’importantes modifications dans l’algorithme de remaillage. Un autre Toy-Model a donc été
développé pour éviter l’apparition de petits angles.
La méthode de modélisation suivante a été proposée : Il faut générer un nombre de points n (environ 20)
sur une distance ε correspondant au rayon de propagation choisi (10cm dans notre cas). Au départ, n points
étaient générés aléatoirement sur cette longueur et ordonnancés dans l’ordre croissant. L’idée principale est
de simuler à l’échelle microscopique la propagation des fissures incluant le contournement des granulats.
Pour représenter la tortuosité, un second tirage aléatoire est fait autour de la direction de propagation. Pour
cela, les points tirés précédemment selon ~x (la direction de propagation) sont écartés selon ~y aléatoirement
sur une longueur fixée. Les points finalement obtenus sont translatés au fond de fissure et subissent une
rotation d’angle α (angle de propagation de fissure), grâce aux matrices de passage de changement de
base. Les points sont donc projetés dans le repère R0 (x~0 , y~0 ) avec x~0 dirigé suivant le sens et la direction de
propagation de la fissure.
Le même problème que pour la première méthode est survenu. La répartition aléatoire des points sur la
droite de propagation générait des points très rapprochés selon x~0 et très écartés selon y~0 ce qui engendrait
des angles très faibles. Dans les algorithmes, les petits angles sont problématiques car les lèvres de la fissure
peuvent se croiser (voir la méthode de propagation de fissure qui sera expliquée plus loin).
Pour éviter ce problème, la méthode suivante est utilisée et est présentée par étapes "Figure 26" :
La longueur ε selon ~x est découpée en n morceaux espacés de ∆x. Ensuite, un point est tiré dans le tiers
médian de chaque portion ∆x (étape a) puis est écarté comme précédemment aléatoirement sur ~y sur une
longueur 2 · ∆x dans l’intervalle [−∆x; ∆x] (étape b). De ce fait, chaque point selon ~x sera écarté au
minimum d’une distance 23 ∆x, ce qui évite les angles très aigus. Les points sont comme précédemment
expliqué, translatés et orientés dans la base R0 (étape c).
Cette façon de faire permet de contourner le problème mais pas de le régler, c’est une des limites de
notre modèle. Il ne permet pas de gérer les angles très petits. Il reste des améliorations à faire pour la gestion
d’angles plus obtus.
8 Progression de la fissure et remaillage 24
Fig. 26: Toy-Model - Version finale
8 Progression de la fissure et remaillage
La progression de la fissure est l’étape durant laquelle la géométrie du problème est recréée. Lorsque
les points du chemin de la fissure ont été générés soit par l’algorithme en chaîne de Markov, soit par le
Toy-Model, il faut créer une nouvelle géométrie en format .geo, l’extension des fichiers GMSH. L’intérêt de
cette étape est de créer à terme un maillage de la géométrie qui pourra être exploité dans le logiciel Cast3m.
Pour créer cette géométrie à partir d’une suite de nouveaux points, le langage Python est utilisé. Grâce
au langage Python, il est possible de modifier le fichier .geo que le logiciel GMSH prend en entrée. Du-
rant cette réécriture plusieurs difficultés se sont présentées. Notamment, GMSH possède une syntaxe de
programmation particulière à laquelle il faut s’adapter en permanence. De nombreuses stratégies ont été
envisagées afin de savoir comment recréer la géométrie du problème sur GMSH. De ces stratégies a été
choisie une méthode pour sa stabilité et sa robustesse qui est détaillée sur les schémas "Figure 27" :
8 Progression de la fissure et remaillage 25
Fig. 27: Création de la nouvelle géométrie
Sur le schéma 1, il est possible d’observer la situation initiale. Dans cette situation, la direction de
propagation est connue, ainsi que l’ancienne géométrie de la fissure et les prochains fonds de fissure générés
(par Toy-Model ou chaine de Markov). Ensuite schéma 2, les parallèles aux segments reliant les fonds de
fissure sont tracées. Ces parallèles distantes d’une épaisseur de fissure : e. L’intersection de deux parallèles
successives, à − 2e ou à + 2e , forment les points permettant la création de la nouvelle géométrie de fissure.
Ces intersections peuvent être observées sur le schéma 3. Pour finir, les nouvelles lignes de la géométrie sont
créées et relient les nouveaux points, ils forment ensemble la nouvelle géométrie visible sur le schéma 4.
Ensuite, un remaillage est nécessaire. En effet, pour effectuer un calcul aux éléments finis, Cast3m a
besoin d’un fichier d’extension .unv contenant le maillage de la nouvelle géométrie. Après avoir écrit le fichier
.geo de cette dernière, le fichier .unv est créé avec GMSH. Cette action est également pilotée depuis Python
à l’aide du module subprocess. Le maillage de la nouvelle géométrie étant créé, il peut alors être exploité
9 Bilan sur le fonctionnement du programme 26
par Cast3m.
9 Bilan sur le fonctionnement du programme
Les différentes étapes de la détermination de la direction et du chemin de propagation de la fissure

peuvent être résumées sous la forme d’un algorithme présenté "Figure 28".
Fig. 28: Structure de l’algorithme
Cet algorithme permet d’avoir une vision globale de la procédure et de comprendre le fonctionnement du
programme codé en Python. Il est à noter que les logiciels utilisés sont libres de droits à des fins éducatives.
Ce programme fonctionne grâce à 6 modules Python créés pour l’occasion. Il possède un “Launcher” per-
mettant une utilisation simple du programme. Il contient également un fichier .dgibi spécifique à Cast3m.
L’ensemble du programme représente 965 lignes de code en langage Python et 102 lignes en langage Cast3m.
L’intégralité du script est disponible en Annexe "A.1".
La "Figure 29" permet d’illustrer visuellement la procédure de propagation de fissure dans son inté-
gralité.
10 Analyse des résultats 27
Fig. 29: Schéma récapitulatif
10 Analyse des résultats
10.1 Notions de déterminisme et probabilisme

Pour analyser les résultats de la méthode, il faut être attentif à l’approche utilisée pour les obtenir et
plus particulièrement à la différence entre l’approche déterministe et l’approche probabiliste.
Les résultats obtenus de façon déterministe sont les valeurs des contraintes au sein de la structure,
calculées grâce à la méthode éléments finis. De ces contraintes a été déduite la direction de propagation. Il
est donc possible de conclure sur cette direction en prenant en compte l’erreur introduite par le calcul aux
éléments finis.
Concernant le chemin de la fissure, il est calculé grâce à une étude probabiliste locale du trajet de fissure.
Il ne correspond donc pas au trajet effectif de la fissure. Néanmoins, il est possible d’émettre des conclusions
sur la tortuosité de la fissure en prenant en compte l’erreur introduite par le calcul MEF de la direction
principale de propagation et l’erreur moyenne introduite par l’approche statistique.
10.2 Convergence et influence des paramètres

Une simulation aux éléments finis se doit d’être conclue par une étude sur la convergence en maillage.
Il est d’usage d’effectuer cette convergence pour chacun des paramètres utilisés pour conclure. N’ayant pas
accès au véritable algorithme d’étude locale de la propagation de fissure, il ne sera pas possible de conclure
sur la notion de tortuosité.
Une convergence a néanmoins été réalisée pour le calcul de l’angle de la direction de propagation "Fi-
gure 30" et "Figure 31", lors de la première itération.
Fig. 30: Convergence en maillage - méthode Directe
Fig. 31: Convergence en maillage - méthode Imagerie
Il a été possible d’atteindre la convergence pour la méthode directe. Il a donc été décidé d’avoir une
erreur de l’ordre de 5%. Le maillage utilisé sera donc de l’ordre de 12 000 mailles.
Pour la méthode par imagerie, les machines de calculs à disposition n’ont pas permis la réalisation d’une
convergence. Il a été constaté que l’angle obtenu restait dans un intervalle de l’ordre de la dizaine de pour-
cents. Néanmoins, ces résultats ne sont pas exploitables sans l’atteinte d’une convergence.
Remise en question des résultats de convergence :
Il a été constaté que les deux méthodes utilisées pour déterminer l’angle de propagation de la fissure sont
extrêmement instables. Les convergences obtenues correspondent à une configuration de paramètres bien
précise. Dans le cas d’une modélisation 2D à loi de comportement linéaire, les maillages utilisés auraient
dû suffire à atteindre la convergence. Les méthodes établies nécessitent donc d’être revues. Néanmoins, les
potentielles sources d’instabilités ont été recensées et nommées paramètres arbitraires.
Il conviendra de trouver des alternatives à ces paramètres arbitraires pour espérer mettre en application
la méthode dans son ensemble. En voici la liste exhaustive :
Méthode directe :
- Echelle des seuils
- Nombre de seuils testés
- Intervalle d’observation des creux de papillon
- Utilisation d’un opérateur de moyenne sur les angles calculés
- Rayon de la zone de plasticité
Méthode par Imagerie :

- Résolution de l’image.
- Intervalle d’observation des creux de papillon
- Opérateur de moyenne sur les angles obtenus
- Echelle de seuils utilisée (calculée à partir des valeurs RGB des pixels de l’image ParaView)
Ces paramètres arbitraires provoquent une grande instabilité de la méthode. Il faut donc émettre une
réserve quant à la reproductibilité de ces convergences pour une autre configuration de paramètres.
Fig. 32: Maillage de la géométrie avec GMSH
De plus, le maillage généré par GMSH "Figure 32" est certainement la source principale du problème
de convergence. Il est possible de voir que le maillage est extrêment affiné proche de la pointe de fissure.
C’est le cas car GMSH a été configuré pour générer un maillage fin en pointe de fissure et au point du
déplacement imposé. Le rapport entre le maillage dans l’ensemble de la structure et le maillage en pointe de
fissure est de 100. Il est également possible de voir que le maillage à cinq centimètres de la pointe de fissure
est plus grossier. Par conséquent, lorsque les convergences ont été réalisées, le nombre de mailles autour de
la pointe de fissure a augmenté cent fois plus rapidement que le nombre de mailles à quelques centimètres
de la pointe de fissure.
Cette façon de générer le maillage n’est pas pertinente pour les méthodes utilisées. En effet, énormé-
ment de mailles sont générées dans une zone à l’éxterieur du sous-domaine d’étude. De ce fait, la matrice de
rigidité K à inverser est de plus en plus grande sans pour autant avoir un impact sur le nombre de mailles
présentes dans le sous-domaine d’étude. C’est pour cette raison que les résultats de la convergence n’ont
pas été concluants.
Voici une proposition pour résoudre le problème : définir deux rayons correspondant aux limites des
sous-domaines de la méthode utilisée. Générer sur ces rayons des points définissant la zone où le maillage
doit-être affiné. Ainsi, la zone dans laquelle le maillage sera fin restera limitée au sous-domaine d’étude.
Un paramètre non arbitraire est la distance à laquelle l’angle de propagation est calculé. En effet, la
longueur de propagation de fissure pour laquelle l’algorithme probabiliste a été éprouvé est de 10 cm. Il
sera donc crucial de déterminer quel sous-domaine d’observation est le plus pertinent pour l’application de
l’algorithme probabiliste.
La "Figure 33" obtenue par la méthode directe trace l’évolution de l’angle de propagation en fonction
de la distance d’étude et de la pointe de fissure.
Fig. 33: Angle de la direction de propagation en fonction de la distance à la pointe de fissure
A la première itération, cet angle a tendance à diminuer lorsque le sous-domaine d’étude s’éloigne de
la pointe de fissure. Ce résultat est tout à fait cohérent avec le chemin de propagation global obtenu
"Figure 34". En effet, la fissure décrit dans la première moitié de son chemin une courbure vers les x
positifs correspondant à une diminution de l’angle de propagation.
10.3 Chemins de propagation obtenus en fonction de la méthode

10.3.1 Fissure décentrée à gauche
Les figures qui suivent sont les géométries obtenues pour les deux méthodes. Les paramètres choisis pour
obtenir de tels résultats sont les suivants : position de la fissure à (x=1,y=0.1), position du chargement à
(x=1.5,y=1), mesh=0.01, meshtip=0.0001, et pour la méthode par imagerie résolution d’image de 400x400
pixels.
Fig. 34: Propagation de la fissure par itération
D’après l’observation des graphiques "Figure 34", la méthode par imagerie semble plus robuste avec
cette gamme de paramètres. En effet, elle effectue une itération de plus que la méthode directe, due aux
limites détaillées dans la partie suivante, que présentent les deux méthodes. Il peut être remarqué également
qu’au premier abord la méthode par imagerie semble donner un parcours de fissure plus réaliste. En effet sur
la fin du parcours celle ci se redresse vers le point d’application du déplacement ce qui semble mécaniquement
intuitif contrairement à la méthode directe dont le parcours se redresse plus lentement.
10.3.2 Fissure centrée

Lorsque l’amorce de fissure est placée sous le point d’application du déplacement et pour la même
gamme de paramètres, la géométrie "Figure 35" est obtenue pour la méthode directe.
Fig. 35: Propagation de la fissure initialisée sous le chargement
Cette simulation permet de tester la validité de la méthode directe.

En effet, lorsque l’amorce de fissure est située sous le point d’application du déplacement, la fissure est
censée progresser verticalement. Dans cet exemple, la fissure s’est propagée en 8 itérations. Pour chaque
itération l’angle calculé est compris dans l’intervalle [78◦ ; 92◦ ].
Ce test de validité n’a pas pu être réalisé avec la méthode par imagerie. Comme il a été expliqué
précédemment, la méthode par imagerie recherche des creux de papillon dans un quart de cercle centré
sur la pointe de fissure défini pour x et y positifs. Dans cette géométrie particulière elle ne peut donc pas
détecter les creux de papillon qui pourraient se situer à des valeurs de x négatives, exemple : angle α = 91◦ .
10.4 Limites et potentiels d’application

Les résultats présentés précédemment correspondent à un cadre où la méthode est applicable. Cepen-
dant, il a été recensé deux limites majeures.
La première limite est la détection du plan de symétrie proche du déplacement imposé. Comme illustré
"Figure 36", les iso-contraintes autour du fond de fissure interfèrent avec les iso-contraintes autour de
la zone de chargement. Cela ne signifie pas nécessairement que la forme de papillon recherchée disparaît
proche du déplacement imposé. Cependant, il semble que leur détection nécessite un maillage plus fin que
ceux utilisés précédemment.
Fig. 36: Imagerie de la contrainte σI avec fissure proche du point d’application du déplacement
Pour gérer ce problème, il a été décidé de relier la fissure existante au bord le plus proche. Cette manière
de faire n’est pas aberrante car à partir d’une certaine ouverture de fissure, celle ci se propage de manière
brutale en direction du bord le plus proche.
La seconde limite concerne les amorces de fissure très excentrées du déplacement imposé. La "Fi-
gure 37" présente le cas d’une amorce décalée de 1 m du déplacement imposé dans la direction des x
négatifs.
Fig. 37: Imagerie de la contrainte σI et du déplacement selon l’axe des x
Il y est constaté deux choses :

L’apparition d’une seule des “ailes” du papillon, avec une contrainte principale σI négative, et le dépla-
cement des lèvres de la fissure. La lèvre droite exerce une pression sur la lèvre gauche.
Ces constatations sont en oppositions totales avec les hypothèses de propagation en mode I.
En effet, la "Figure 38" révèle l’apparition de courbes en ailes de papillon selon les contraintes σII ,
ainsi que le déplacement des lèvres en direction opposée selon l’axe ~y . Dans les cas d’amorces trop excen-
trées, il y a sollicitation en Mode II. La méthode développée ne peut donc pas s’appliquer.
Fig. 38: Imagerie de la contrainte σII et du déplacement selon l’axe des y

11 Conclusion 36
11 Conclusion
Tout d’abord, le sujet d’étude de ce rapport est à l’heure actuelle un domaine de recherche actif.
Les méthodes proposées sont fondées sur l’interprétation mécanique des iso-valeurs des contraintes prin-
cipales. Il existe probablement d’autres approches utilisant divers opérateurs mathématiques. Néanmoins,
les recherches sur le sujet n’abordent pas d’autres pistes à notre connaissance. Il n’existe pas non plus de
méthode semblable, à notre connaissance. Une comparaison avec d’autres simulations existantes sera donc
nécessaire pour conclure sur la fiabilité de la théorie.
Pour conclure sur les méthodes développées, il semblerait que les deux méthodes soient prometeuses. Il
reste des ajustements à apporter aux paramètres arbitraires ainsi qu’à la génération du maillage.
Néanmoins, le chemin de propagation obtenu semble globalement satisfaisant. De plus, le temps de
calcul nécessaire à l’obtention d’un chemin de propagation entier est inférieur à cinq minutes pour les deux
méthodes. Enfin, la prise en compte des modes II et III semble envisageable en apportant des modifi-
cations au programme développé. La méthode d’estimation de la direction de propagation pourrait donc
répondre à ses ambitions.
Enfin sur un plan pédagogique, la grande majorité des logiciels utilisés avaient déjà été plus ou moins
introduits en cours. Ce projet fut l’occasion d’approfondir leur utilisation et d’apprendre à les mettre en
interaction. Ainsi, outre l’acquisition d’une réelle culture d’ingénieur concernant la simulation numérique
de la rupture, ce projet a été l’occasion de se confronter à une problématique complexe. Ce qui semble se
rapprocher d’un travail d’ingénieur.
11 Conclusion 37
Table des figures
1 Faiençage - Fissure - Fracture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

2 Contrainte principale σI à déplacement imposé de 1mm sur la face droite dans la direction
x, sans et avec imperfection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
3 Lien entre triaxialité, déformation et contrainte à rupture . . . . . . . . . . . . . . . . . . 2
4 Modes de propagation de fissure - Approche cinématique . . . . . . . . . . . . . . . . . . 3
5 Défaut elliptique au sein d’une structure solicitée en mode I . . . . . . . . . . . . . . . . 3
6 Contrainte σθ en fonction de la distance à la pointe de fissure . . . . . . . . . . . . . . . . 4
7 Propagation d’une fissure en mode I pur . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
8 Méthode de détermination des noeuds candidats . . . . . . . . . . . . . . . . . . . . . . . 6
9 Problème flexion trois points à fissure décentrée . . . . . . . . . . . . . . . . . . . . . . . 7
10 Composition du matériau simulé : Béton . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
11 Structure globale du programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
12 Contenu du fichier au format .inp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
13 Premières idées illustrées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
14 Forme d’ailes de papillon observées en pointe de fissure . . . . . . . . . . . . . . . . . . . 13
15 Schématisation des sous-domaines d’observation . . . . . . . . . . . . . . . . . . . . . . . 14
16 Position du point de Gauss au sein d’un trièdre . . . . . . . . . . . . . . . . . . . . . . . 15
17 Directe - Sous-domaine d’étude et détermination du creux, étape 1 . . . . . . . . . . . . . 16
18 Directe - Sous-domaine d’étude et détermination du creux, étape 2 . . . . . . . . . . . . . 17
19 Zone délimitant le voisinage d’une pointe de fissure . . . . . . . . . . . . . . . . . . . . . 18
20 Imagerie des iso-contraintes σI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
21 Imagerie - Détection du creux : (a) méthode des contours ; (b) méthode simplifiée . . . . . 20
22 Imagerie - Domaine d’observation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
23 Imagerie - Valeurs de seuils testés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
24 Imagerie - Résultat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
25 Toy Model - Version 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
26 Toy-Model - Version finale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
27 Création de la nouvelle géométrie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
28 Structure de l’algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
29 Schéma récapitulatif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
30 Convergence en maillage - méthode Directe . . . . . . . . . . . . . . . . . . . . . . . . . 28
31 Convergence en maillage - méthode Imagerie . . . . . . . . . . . . . . . . . . . . . . . . . 28
32 Maillage de la géométrie avec GMSH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
33 Angle de la direction de propagation en fonction de la distance à la pointe de fissure . . . . 31
34 Propagation de la fissure par itération . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
35 Propagation de la fissure initialisée sous le chargement . . . . . . . . . . . . . . . . . . . . 33
36 Imagerie de la contrainte σI avec fissure proche du point d’application du déplacement . . 34
37 Imagerie de la contrainte σI et du déplacement selon l’axe des x . . . . . . . . . . . . . . 35
38 Imagerie de la contrainte σII et du déplacement selon l’axe des y . . . . . . . . . . . . . . 35
11 Conclusion 38
Références
[1] Eurocode 2 - calcul des structures en béton. Technical report, 2005.

[2] Reprise des bétons dégradés. Technical report, Fédération Nationale des Travaux Publics, Fédération
Française du Bâtiment, 2008.
[3] Traitements des fissures par calfeutrement ou pontage et protection localisée ou création d’un joint
de dilatation. Technical report, Fédération Nationale des Travaux Publics, Fédération Française du
Bâtiment, 2008.
[4] Griffith A.A. The phenomena of rupture and flow in solids. 1920.
[5] Clément BERTHINIER. État des entrées/sorties de cast3m.
[6] Céline CAU. Le béton.
[7] André Chrysochoos. Milieu hétérogène en élasticité linéaire.
[8] Thomas Elguedj. Simulation numérique de la propagation de fissure en fatigue par la méthode des
éléments finis étendus : prise en compte de la plasticité et du contact-frottement.
[9] Irwin G.R. Fracture Dynamics. 1948.
[10] Laghrour KHENCHELA. Fatigue des matériaux cours et excercies.
[11] Shixiang Ma. Propagation de fissure en mode mixte dans un milieu élasto-plastique avec prise en
compte des contraintes résiduelles.
[12] Thomas Pardoen. Mécanique de la rupture et son lien avec la métallurgie.
[13] Pierre Suquet. Rupture et plasiticté.
[14] Sylvia Feld-Payet Guy Le Besnerais Vincent Bonnand Didier Pacou Léo Thiercelin. Crack path tracking
from full field measurements : a novel empirical methodology.
A Annexes 39
A Annexes
A.1 Script
# -*- coding: utf-8 -*-
"""
CE PROGRAMME EST L'ALGORITHME PROJET MEF FISSURE MI4
@authors: Lucas DEPIEDS / William LE GOFF / Lucas CUISSET
"""
#IMPORT DES MODULES DU PROJET

from Initialisation import *
from IMAGERIE import *
from progression_fissure import *
from DPAD_calibre import *
from Boite_noire import *
from math import *
import shutil
import os
#CHOIX DE LA METHODE
methode=1 # 0=méthode imagerie/ 1=méthode directe
#INITIALISATION DU .geo AVEC GEOMETRIE DU PROBLEME

PositionForce=[1.5,1]
PositionFissure=[1.5,0.1]
mesh=0.01
meshtip=mesh/100
largeur=3
hauteur=1
largeur_fissure=0.0001
initialisation(largeur,hauteur,PositionForce[0],PositionFissure[0],PositionFissure[1],mesh,meshtip,largeur_fissure)
distance_de_propagation=0.1
#VARIABLES UTILES:
erreur=0
i=1
stockage_des_angles=[]
#EFFACE LES SAUVEGARDES DES .geo PRECEDENTES

for element in os.listdir('C:/crack_simulator/gmsh_save'):
os.remove('C:/crack_simulator/gmsh_save/'+str(element))
while erreur==0:
#MESH
list_commande1 = ['C:\\Users\\Lucas\\Desktop\\gmsh', 'C:\\crack_simulator\\fichiers_temp\\fondation.geo', '-2',
'-format', 'unv', '-o', 'C:\\crack_simulator\\fichiers_temp\\mesh.UNV']
subprocess.run(list_commande1,stdout=subprocess.DEVNULL,stderr=subprocess.STDOUT)
print(i,'itération(s) le mesh a été réalisé')
#CASTEM
list_commande2 = ['C:\\Cast3M\\PCW_19\\bin\\castem19.bat','C:\\crack_simulator\\castem_fic\\Fissure.dgibi']
print(i,'itération(s) execution du dgibi a été réalisée')
if methode==0:
#DETERMINATION DE LA DIRECTION PRINCIPALE PAR IMAGERIE

direction__principale_IMG=dir_prin_imagerie(PositionFissure)
if direction__principale_IMG=='error':
#DETECTION DES EVENTUELLES ERREURS
print(i,'itération(s) les creux du papillon ne sont plus detectés pas d angle à determiner')
erreur=1
angle=pi/2
epsi=hauteur-PositionFissure[1]
Positions=boite_noire(PositionFissure,angle,epsi,hauteur)
print(i,'itération(s) les points ont été générés')
else:
print(i,'itération(s) détermination angle',direction__principale_IMG,'degrés réalisée')
angle=direction__principale_IMG*pi/180
#SIMULATION ALGORITHME THESARDE
Positions=boite_noire(PositionFissure,angle,distance_de_propagation,hauteur)
if methode==1:
#DETERMINATION DE LA DIRECTION PRINCIPALE PAR METHODE DIRECTE

direction_principale_DPMD=execute_all(PositionFissure,PositionForce,0.1,0.09)
stockage_des_angles.append(direction_principale_DPMD)
if (direction_principale_DPMD=='error') or (len(stockage_des_angles)>2 and abs(stockage_des_angles[-1]-stockage_des_angles[-2])>15
#DETECTION DES EVENTUELLES ERREURS
print(i,'itération(s) les creux du papillon ne sont plus detectés pas d angle à determiner')
erreur=1
angle=pi/2
epsi=hauteur-PositionFissure[1]
Positions=boite_noire(PositionFissure,angle,epsi,hauteur)
else:
print(i,'itération(s) détermination angle',direction_principale_DPMD,'degrés réalisée')
#SIMULATION ALGORITHME THESARDE
angle=direction_principale_DPMD*pi/180
1
Positions=boite_noire(PositionFissure,angle,distance_de_propagation,hauteur)
#REFORMATION DU .geo
remaillage('C:\\crack_simulator\\fichiers_temp\\fondation.geo',PositionForce,mesh,meshtip,Positions)
gmshsave='iteration'+str(i)+'.geo'
shutil.copyfile('C:/crack_simulator/fichiers_temp/fondation.geo', 'C:/crack_simulator/gmsh_save/'+gmshsave)
print(i,'itération(s) le .geo a été mis à jour')
#MISE A JOUR DES PARAMETRES

PositionFissure=[Positions[-1][0],Positions[-1][1]]
print(i,'itération(s) les paramètres ont été mis à jour')
i=i+1
2
# -*- coding: utf-8 -*-
"""
Module Initialisation creation du fichier de base, avec une amorce de fissure sur structure.
"""
def initialisation(largeur,hauteur,posforce,posfiss,fisslength,mesh,meshtip,epsi):
"""
ENTREE:
Les arguments sont les paramètres géométriques du problème
SORTIE:
un fichier.geo de la géométrie initiale du problème.
"""
with open("C:\\crack_simulator\\fichiers_temp\\fondation.geo","w") as file:
file.write('Point(1) = {'+str(posfiss)+', '+str(fisslength)+', 0, '+str(meshtip)+'};\n')

file.write('Point(2) = {'+str(posfiss-epsi)+', 0, 0, '+str(mesh)+'};\n')
file.write('Point(3) = {0.1, 0, 0, '+str(mesh)+'};\n')
file.write('Point(4) = {0, 0, 0, '+str(mesh)+'};\n')
file.write('Point(5) = {0, '+str(hauteur)+', 0, '+str(mesh)+'};\n')
file.write('Point(6) = {'+str(posforce-0.1)+', '+str(hauteur)+', 0, '+str(mesh)+'};\n')
file.write('Point(7) = {'+str(posforce)+', '+str(hauteur)+', 0, '+str(meshtip)+'};\n')
file.write('Point(8) = {'+str(posforce+0.1)+', '+str(hauteur)+', 0, '+str(mesh)+'};\n')
file.write('Point(9) = {'+str(largeur)+', '+str(hauteur)+', 0, '+str(mesh)+'};\n')
file.write('Point(10) = {'+str(largeur)+', 0, 0, '+str(mesh)+'};\n')
file.write('Point(11) = {'+str(largeur-0.1)+', 0, 0, '+str(mesh)+'};\n')
file.write('Point(12) = {'+str(posfiss+epsi)+', 0, 0, '+str(mesh)+'};\n')
file.write('Line(1)={1, 2};\n')
file.write('Curve Loop(1) = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};\n')

file.write('Plane Surface(1) = {1};\nPhysical Surface("SURFT") = {1};')
1
# -*- coding: utf-8 -*-
"""
Module Boite_noire
"""
import random
from math import *
import matplotlib.pyplot as plt
from numpy import *
from random import *
def boite_noire(po, alpha, eps,yplaque):

"""
-Fonction boite noire censée mimer la comportement de l'aglotirthme par apprentissage
-Po correspond aux coordonnées du fond de fissure à l'itération précédente
-alpha est l'angle de la direction principale de contrainte par rapport à l'horizontale du repère cartésien
-eps : taille du mini-volume
po coordonnée de la pointe
alpha direction principale
eps hauteur dans laquelle la fissure va se propager
eps=10cm
p liste des fonds de fissure
"""
n = 20 # le nombre de points de fissure à générer
pa=[0,0] #point A position fissure dans le cadre (en bas à gauche)
p = [] # p la liste des points par lesquels passe la fissure
pb=[eps*cos(alpha)+po[0],eps*sin(alpha)+po[1]] #point B sens de propagation avec angle alpha
dx=eps/n
if pb[1]>yplaque:
pb=[((-pb[1]+yplaque)/tan(alpha))+pb[0],yplaque]
#creation tirage aléatoire le long de AB:

xi=[]
yi=[]
ec=eps/n #ecart-type
for i in range(2*n):
xi.append(uniform(((1/3+i)*dx),((2/3+i)*dx)))
yi.append(uniform(-ec/2,ec/2))
xi.sort() #trier val
P_1=[[cos(alpha),-sin(alpha)],[sin(alpha),cos(alpha)]] #matrice inverse de passage
# #conditions pour ne pas que les points sortent du cadre

xmin=pa[0]
ymin=pa[1]
xmax=pb[0]
ymax=pb[1]
for i in range(n):
xnouv=P_1[0][0]*xi[i]+P_1[0][1]*yi[i]+po[0]
ynouv=P_1[1][0]*xi[i]+P_1[1][1]*yi[i]+po[1]
if (xnouv < xmax) and (xnouv > xmin) and (ynouv < ymax) and (ynouv > ymin):
p.append([xnouv,ynouv])
p.append([pb[0],pb[1]]) #on ajoute le point b comme dernier point
# # plot:
# plt.plot([pa[0]+po[0],pb[0]], [pa[1]+po[1],pb[1]], 'r-', lw=1) # Red straight line
# for i in range(len(p)):
# plt.plot(p[i][0],p[i][1],'x')
# plt.show()
return p
1
# -*- coding: utf-8 -*-
"""
Module DPAD_calibre détermination de la direction principale par méthode directe
"""
import re
from math import tan, atan2, pi
from statistics import mean
#_____________________________________________________________________________#
def analyseur(fichier_contrainte_principale):
"""
ENTREE:
l'argument fichier_contrainte_principale correspond au fichier au format .inp
sorti par castem contenant les contraintes principales
SORTIE:
La fonction analyseur sort 3 listes :
Noeuds : comprenant les noeuds du maillage de gmsh

de la forme [n° du noeud, abscisse, ordonnee]
Mailles : comprenant les mailles composant le maillage de gmsh ainsi que les
trois noeuds par lequels elles sont défini.
de la forme [n° maille, n°noeuds1, n°noeuds2, n°noeuds3 ]
Contprin : comprenant la valeur de la contrainte principale maximale SIG11

au milieu d'une maille (aussi appelé point de Gauss de la maille)
de la fome [n° maille, SIG11]
"""
Noeuds=[]
Mailles=[]
ContPrin=[]
f= open(fichier_contrainte_principale,'r')
verif=re.search('([0-9]+)\s+([0-9]+)\s+([0-9]+)\s+([0-9]+)',f.read())
f.close
f= open(fichier_contrainte_principale,'r')
for ligne in f:
AA=re.search('\s+(\d+)\s+(\d\.\w+[\+|\-]\w+)\s+(\d\.\w+[\+|\-]\w+)',ligne)
if AA and len(Noeuds)<int(verif.group(1)):
Noeuds.append([int(AA.group(1)),float(AA.group(2)),float(AA.group(3))])
else:
BB=re.search('\s+(\d+) 2\s+tri\s+(\d+)\s+(\d+)\s+(\d+)',ligne)
if BB and len(Mailles)<int(verif.group(2)):
Mailles.append([int(BB.group(1)),int(BB.group(2)),int(BB.group(3)),int(BB.group(4))])
else:
CC=re.search('\s+(\d+)\s+([ |\-]\d\.\w+[\+|\-]\w+)\s+([ |\-]\d\.\w+[\+|\-]\w+)\s+([ |\-]\d\.\w+[\+|\-]\w+)\s'+
'+([ |\-]\d\.\w+[\+|\-]\w+)\s+([ |\-]\d\.\w+[\+|\-]\w+)\s+([ |\-]\d\.\w+[\+|\-]\w+)\s+([ |\-]\d\.\w'+
'+[\+|\-]\w+)\s+([ |\-]\d\.\w+[\+|\-]\w+)',ligne)
if CC and len(ContPrin)<int(verif.group(2)):
ContPrin.append([int(CC.group(1)),float(CC.group(2))])
return([Noeuds,Mailles,ContPrin])
f.close
#_____________________________________________________________________________#
def analyseur2(fichier_contrainte_vonmises):
"""
ENTREE:
l'argument fichier_contrainte_vonmises correspond au fichier au format .inp
sorti par castem contenant les contraintes.
SORTIE:
La fonction analyseur2 sort 1 liste :
ContVM : comprenant la contrainte équivalente au sens de VON MISES aux points

de Gauss du maillage de GMSH
de la forme [n° maille, SIG_eq_VONMISES]
"""
ContVM=[]
f= open(fichier_contrainte_vonmises,'r')
verif=re.search('([0-9]+)\s+([0-9]+)\s+([0-9]+)\s+([0-9]+)',f.read())
f.close
f= open(fichier_contrainte_vonmises,'r')
for ligne in f:
CC=re.search('\s+(\d+)\s+([ |\-]\d\.\w+[\+|\-]\w+)\s+([ |\-]\d\.\w+[\+|\-]\w+)\s+([ |\-]\d\.\w+[\+|\-]\w+)\s'+
'+([ |\-]\d\.\w+[\+|\-]\w+)',ligne)
if CC and len(ContVM)<int(verif.group(2)):
VMTEMP=(0.5*((float(CC.group(2))-float(CC.group(3)))**2+(float(CC.group(3))-float(CC.group(4)))**2+
(float(CC.group(4))-float(CC.group(2)))**2)+3*(float(CC.group(5))**2))**0.5
ContVM.append([int(CC.group(1)),VMTEMP])
return(ContVM)
1
f.close
#_____________________________________________________________________________#
def Contrainte(Noeuds,Mailles,ContPrin,ContVM):
"""
ENTREE:
les listes en arguments d'entée de Contrainte correspondent aux listes en
sortie des fonctions analyseur et analyseur2
SORTIE:
La fonction Contrainte sort 1 liste :
Data : comprenant les coordonées des points de Gauss de toutes les mailles du
domaine, la contrainte principale maximale aux points de Gauss et la contrainte
équivalente au sens de VON MISES aux points de Gauss.
de la forme [abscisse, ordonnée, SIG11, SIG_eq_VONMISES]
"""
Data=[]
for i in range(len(Mailles)):
temp=[]
temp.append((Noeuds[Mailles[i][1]-1][1]+Noeuds[Mailles[i][2]-1][1]+Noeuds[Mailles[i][3]-1][1])/3)
temp.append((Noeuds[Mailles[i][1]-1][2]+Noeuds[Mailles[i][2]-1][2]+Noeuds[Mailles[i][3]-1][2])/3)
for j in range(len(ContPrin[1])-1):
temp.append(ContPrin[Mailles[i][0]-1][j+1])
temp.append(ContVM[i][1])
Data.append(temp)
return Data
#_____________________________________________________________________________#
def usefullDATA(PositionFissure,PositionForce,Data,RayonMaximalTraitement):
"""
ENTREE:
PositionFissure correspond aux coordonnées de la pointe de fissure
PositioinForce correspond aux coordonnées du point d'application de la force
Data correspond à la liste en sortie de la fonction Contrainte
SORTIE:
La fonction usefullData sort 4 liste :
abscisse, ordonne, sigmain et sigvm de tel sorte que la n-ième valeur des
listes correspondent au même point de GAUSS
Sont définis comme "utiles" les points de Gauss répondant au conditions définies
plus loin
"""
Distance_minimale=0.01 #Rayon de non application LEFM
#pente de la droite entre la pointe de fissure et le point d'application de la force

#tangalphaD=(PositionForce[1]-PositionFissure[1])/(PositionForce[0]-PositionFissure[0])
TEMPSIGMAX=[]
abscisse=[]
ordonne=[]
sigmain=[]
sigvm=[]
#début du tri des data utiles
for i in range(len(Data)):
#Condition 1 : Pt de Gauss compris dans le quart d'origine PositionFissure
# et orienté dans le direction de Position force (ou selon tangalphaD)
if PositionForce[0]!=PositionFissure[0]: #permet d'éviter la divions par zero
if Data[i][1]>(tan(atan2((PositionForce[1]-PositionFissure[1]),(PositionForce[0]-PositionFissure[0]))
-pi/4)*(Data[i][0]-PositionFissure[0])+PositionFissure[1]):
if Data[i][0]>(Data[i][1]-PositionFissure[1])/tan(atan2((PositionForce[1]-PositionFissure[1]),
(PositionForce[0]-PositionFissure[0]))+pi/4)+PositionFissure[0]:
#Condition 2: la contrainte principale maximale est positive
if Data[i][2]>=0:
#Condition 3: le Pt appartient au rayon de traitement
if (((Data[i][0]-PositionFissure[0])**2+(Data[i][1]-PositionFissure[1])**2)**0.5)<=RayonMaximalTraitement:
abscisse.append(Data[i][0])
ordonne.append(Data[i][1])
sigmain.append(Data[i][2])
sigvm.append(Data[i][3])
if (((PositionFissure[0]-Data[i][0])**2+(PositionFissure[1]-Data[i][1])**2)**0.5)>=Distance_minimale:
TEMPSIGMAX.append(Data[i][2])
else:
2
if Data[i][1]>(tan(pi/2-pi/4)*(Data[i][0]-PositionFissure[0])+PositionFissure[1]):
if Data[i][0]>(Data[i][1]-PositionFissure[1])/tan(pi/2+pi/4)+PositionFissure[0]:
#Condition 2: la contrainte principale maximale est positive
if Data[i][2]>=0:
#Condition 3: le Pt appartient au rayon de traitement
if (((Data[i][0]-PositionFissure[0])**2+(Data[i][1]-PositionFissure[1])**2)**0.5)<=RayonMaximalTraitement:
abscisse.append(Data[i][0])
ordonne.append(Data[i][1])
sigmain.append(Data[i][2])
sigvm.append(Data[i][3])
if (((PositionFissure[0]-Data[i][0])**2+(PositionFissure[1]-Data[i][1])**2)**0.5)>=Distance_minimale:
TEMPSIGMAX.append(Data[i][2])
if len(TEMPSIGMAX)<=1:
print('ligne 185')
return('error','error','error','error','error')
else:
EchelleMaxContraintePrincipale=max(TEMPSIGMAX)
return(abscisse,ordonne,sigmain,sigvm,EchelleMaxContraintePrincipale)
#_____________________________________________________________________________#
def seuilANDcreux(abscisse,ordonne,sigmain,sigvm,Nseuil,EchelleMaxContraintePrincipale,PositionFissure):
#Seuillage et Détermination du creux dans le quart centré sur Pforce et Pfiss
"""
ENTREE:
les listes en entrée de seuilANDcreux correspondent à celles en sortie de
usefullDATA
SORTIE:
La fonction seuilANDcreux sort 3 listes :
creuxpapillonX, la liste comprenant l'abscisse du z-ième creux de papillon
correspondant à un seuil égal à exp(xfexpmin+(z+1)*DeltaCont)
creuxpapillonY, la liste comprenant l'ordonnee du z-ième creux de papillon
correspondant à un seuil égal à exp(xfexpmin+(z+1)*DeltaCont)
creuxpapillonMAINla liste comprenant la contrainte principale maximale du
z-ième creux de papillon correspondant à un seuil égal à exp(xfexpmin+(z+1)*DeltaCont)
Sont définis comme "utiles" les points de Gauss répondant au conditions définies
plus loin
"""
#définis le nombre de creux cherchés (inutiles d'en cherche trop car maillage limité)
#utilisation d'une echelle de seuil en 1/racine(2piR) (correspond bien

#aux fort gradient de contrainte aux alentours de la fissure)
#à voir si d'autres fonctions de seuils seraient plus adpatées
#xfexpmin=log(int(min(sigmain))+int((max(sigmain)-min(sigmain))/Nseuil))
#xfexpmax=log(int(max(sigmain)))
xfracinemin=((1/(min(sigmain)+int((EchelleMaxContraintePrincipale-min(sigmain))/Nseuil)))**2)/(2*pi)
xfracinemax=((1/(EchelleMaxContraintePrincipale-int((EchelleMaxContraintePrincipale-min(sigmain))/Nseuil)))**2)/(2*pi)
DeltaCont=((xfracinemax)-xfracinemin)/(Nseuil+3)
#ajustement=40
#DeltaCont=(xfexpmax-xfexpmin)/(Nseuil+ajustement)
creuxpapillonX=[]
creuxpapillonY=[]
creuxpapillonMAIN=[]
TEMPORAIREX=[] #permet d'imager les points compris dans un seuil (débugage)

TEMPORAIREY=[]
for z in range(Nseuil):
#i=exp(xfexpmin+(z+1)*DeltaCont) #on veut éviter les papillons qui dépassent du cadre
#Seuil de contrainte en 1/racine(2piR)
i=1/((2*pi*(xfracinemin+z*DeltaCont))**0.5)
#print(i)
TEMPORAIREX.append([])
TEMPORAIREY.append([])
3
Ntemp=0 #compteur du nombre de pt supprimé
#plt.scatter(abscisse,ordonne)
tempdistmin=100 #distance minimale entre creux papillon et pointe fissure
for j in range(len(sigmain)):
if sigmain[j-Ntemp]<=i:
if (((PositionFissure[0]-abscisse[j-Ntemp])**2+(PositionFissure[1]-ordonne[j-Ntemp])**2)**0.5)<=tempdistmin:
tempdistmin=((PositionFissure[0]-abscisse[j-Ntemp])**2+(PositionFissure[1]-ordonne[j-Ntemp])**2)**0.5
tempcreuxpapillon=[abscisse[j-Ntemp],ordonne[j-Ntemp],sigmain[j-Ntemp]]
TEMPORAIREX[z].append(abscisse[j-Ntemp])
TEMPORAIREY[z].append(ordonne[j-Ntemp])
#sigmain.pop(j-Ntemp)
#abscisse.pop(j-Ntemp)
#ordonne.pop(j-Ntemp)
#Ntemp=Ntemp+1
creuxpapillonX.append(tempcreuxpapillon[0])
creuxpapillonY.append(tempcreuxpapillon[1])
creuxpapillonMAIN.append(tempcreuxpapillon[2])
return(creuxpapillonX,creuxpapillonY,creuxpapillonMAIN,TEMPORAIREX,TEMPORAIREY)
#_____________________________________________________________________________#
#détermination de l'angle de la direction principale + imagerie pour débugage

#non terminé donc pas sous forme de fonction
def fin_du_game(creuxpapillonX,creuxpapillonY,PositionFissure,TRACE,Nseuil,RayonMaximalTraitement,RayonMinimalTraitement):
teta=[]
Rpapillon=[]
for i in range(len(creuxpapillonX)):
teta.append(atan2((creuxpapillonY[i]-PositionFissure[1]),(creuxpapillonX[i]-PositionFissure[0]))*360/(2*pi))
Rpapillon.append(((PositionFissure[0]-creuxpapillonX[i])**2+(PositionFissure[1]-creuxpapillonY[i])**2)**0.5)
n=0
#print(Rpapillon)
for i in range(len(Rpapillon)):
#définit le tube dans lequel on cherche les creux de papillons
if Rpapillon[i-n]<RayonMaximalTraitement and Rpapillon[i-n]>RayonMinimalTraitement :
Rpapillon.pop(i-n)
teta.pop(i-n)
n+=1
if len(teta)<=1:
print('ligne 285')
return('error')
Directionprincipale=mean(teta)
if TRACE==1:
fig=plt.figure(frameon=False)
ax=plt.Axes(fig, [0.,0.,3.,3.])
ax.set_axis_on()
ax.set_xlim(0,0.1)
ax.set_ylim(70,80)
fig.add_axes(ax)
fig=plt.scatter(Rpapillon,teta)
plt.savefig(str(Nseuil)+'.png',bbox_inches='tight',transparent=False,pad_inches=0)
return(Directionprincipale)
def Anglesdifseuils(convdir,convergence):
anglemoyen=mean(convdir)
#print('angle moyen calculé entre 8 et 10cm ='+str(anglemoyen))
TRACE=0
if TRACE==1:
fig=plt.figure(frameon=False)
#fig.set_size_inches(max(creuxpapillonX)-min(creuxpapillonX),max(creuxpapillonY)-min(creuxpapillonY))
ax=plt.Axes(fig, [0.,0.,4.,4.])
ax.set_axis_on()
fig.add_axes(ax)
#ax.imshow(img_gaus[:,:],aspect='auto')
fig=plt.scatter(convergence,convdir)
plt.savefig('lisse3.png',bbox_inches='tight',transparent=False,pad_inches=0)
return(anglemoyen)
##############################################################################
#rayon Max et Min de traitement définissent l'arc de cercle dans lequel on cherche les creux de papillon
def execute_all(PositionFissure,PositionForce,RayonMaximalTraitement,RayonMinimalTraitement):
#fichiers comprenants les calculs CASTEM
4
fichier_contrainte_principale='C:\\crack_simulator\\fichiers_temp\\CONTPRIN.inp'
#fichier_contrainte_vonmises='C:\\Users\\Lucas\\Desktop\\Projet_Fissures\\PYTHON\\BOUCLE\\VONMISES.inp'
Noeuds,Mailles,ContPrin=analyseur(fichier_contrainte_principale)
#ContVM=analyseur2(fichier_contrainte_vonmises)
#Prévu si un jour les contraintes de VM se révèlent importantes
ContVM=[]
for i in range(len(ContPrin)):
ContVM.append([i+1,0])
#permet de faire tourner le programme sans rien modifier sans contrainte de VON MISES
#vérification de la concordance des maillages
if (len(Mailles)==len(ContPrin)) and (len(ContPrin)==len(ContVM)):
Data=Contrainte(Noeuds,Mailles,ContPrin,ContVM)
else:
print('erreur,les fichiers .inp ne correspondent pas au même calcul CASTEM')
Noeuds.clear()
Mailles.clear()
ContPrin.clear()
ContVM.clear()
####
convergence=[]
convdir=[]
for Nseuil in range(1000,1001,50):
convergence.append(Nseuil)
abscisseITER,ordonneITER,sigmainITER,sigvmITER,EchelleMaxContraintePrincipale
=usefullDATA(PositionFissure,PositionForce,Data,RayonMaximalTraitement)
if abscisseITER=='error':
return('error')
creuxpapillonX,creuxpapillonY,creuxpapillonMAIN,TEMPORAIREX,TEMPORAIREY
=seuilANDcreux(abscisseITER,ordonneITER,sigmainITER,sigvmITER,Nseuil,EchelleMaxContraintePrincipale,PositionFissure)
TRACE=0 #trace si TRACE=1
Directionprincipale=
fin_du_game(creuxpapillonX,creuxpapillonY,PositionFissure,TRACE,Nseuil,RayonMaximalTraitement,RayonMinimalTraitement)
if Directionprincipale=='error':
return('error')
convdir.append(Directionprincipale)
anglemoyen=Anglesdifseuils(convdir,convergence)
return(anglemoyen)
5
# -*- coding: utf-8 -*-
"""
Module IMAGERIE DETERMINATION DE LA DIRECTION PRINCIPALE PAR LA METHODE IMAGERIE
"""
#_____________________________________________________________________________#
from math import *
from PIL import Image
from numpy import *
import numpy as np
import subprocess
#_____________________________________________________________________________#
def picture_generator(pos_fiss):
"""
ENTREE:
une liste de deux éléments: l'abscisse et l'ordonnée du fond de fissure.
SORTIE:
None
Cette fonction permet de modifier la macro de ParaView afin d'effectuer un

screenshot au fond de fissure.
"""
Xfiss=pos_fiss[0]
Yfiss=pos_fiss[1]
fichier=open("C:\\crack_simulator\\modules\\macrofiss.py", "r")
lignes=fichier.readlines()
lignes[108]='renderView1.CameraPosition = ['+str(Xfiss)+','+str(Yfiss)+', 10000.0]\n'
lignes[109]='renderView1.CameraFocalPoint = ['+str(Xfiss)+','+str(Yfiss)+', 0.0]\n'
fichier=open("C:\\crack_simulator\\modules\\macrofiss.py","w")
fichier.writelines(lignes)
fichier.close()
list_commande2 = ['C:\\Program Files\\ParaView 5.8.0-Windows-Python3.7-msvc2015-64bit\\bin\\pvpython.exe','C:\\crack_simulator\\modules
#_____________________________________________________________________________#
def Traitement_Image(imag):
xd='nothing has happen'
resolution = imag.size # dimensions image:
# coordonnées point fissure (milieu image):

xfiss =int( resolution[0]/2)
yfiss =int( resolution[1]/2)
#où on regarde:
min=0.7*int( resolution[1]/2)# debut rayon 7 cm
max=int( resolution[1]/2) #max r=10cm
#selection des points:

usefull_data=[]
for i in range(resolution[0]):
for j in range(resolution[1]):
if (i>xfiss) and (j<yfiss) and (((i-xfiss)**2+(j-yfiss)**2)<=max**2) and (((i-xfiss)**2+(j-yfiss)**2)>=min**2):
usefull_data.append([i,j,imag.getpixel((i,j))])
nbpts=len(usefull_data)
agl=[] #liste des angles
#coord points crack_simulatorés et correspondants à la condition:

TEMPORAIREX=[]
TEMPORAIREY=[]
contours = []
eps=0.1*resolution[1]/20 #distance mini à laquelle on regarde les points exterieurs à l'arc de cercle
Sanc=[3*257] #definition Seuil ancien, initialisation à valeur max impossible
for k in range(nbpts): # k parcourt la liste des points à crack_simulatorer
contours.append([])
seuil = imag.getpixel(((usefull_data[k][0]),usefull_data[k][1]))[0]
+ imag.getpixel(((usefull_data[k][0]),usefull_data[k][1]))[1]+imag.getpixel(((usefull_data[k][0]),usefull_data[k][1]))[2]
#vérification de ce seuil:
if seuil not in Sanc:
#binarisation: on garde que les points noirs (exterieur) dans contours
for i in range(nbpts):
Nblanc = imag.getpixel((usefull_data[i][0], usefull_data[i][1]))[0]
+imag.getpixel((usefull_data[i][0], usefull_data[i][1]))[1]+imag.getpixel((usefull_data[i][0], usefull_data[i][1]))[2]
if Nblanc > seuil:
contours[k].append([usefull_data[i][0],usefull_data[i][1]])
1
# Determiner point le plus proche :
dmin=resolution[0]*2 #initialisation distance
for i in range(len(contours[k])):
di=sqrt((contours[k][i][0]-xfiss)**2+(contours[k][i][1]-yfiss)**2)
if di<dmin:
dmin=di
xd=contours[k][i][0]
yd=contours[k][i][1]
if xd!='nothing has happen':
if (((xd-xfiss)**2+(yd-yfiss)**2)>(min+eps)**2): #on enleve les points les plus porhces dans l'arc de cercle
if (xd not in TEMPORAIREX) and (yd not in TEMPORAIREY):
#calcul de l'angle avec l'horizontale :

angle = atan2(abs(yd-yfiss),abs(xd-xfiss)) #en radian, abs pour l'axe retourné des y
angle=angle*180/pi #en degrés
agl.append(angle)
TEMPORAIREY.append(yd)
Sanc.append(seuil)
else:
return('error')
#enlever le point sur le bord superieur:
mini=resolution[1]
for i in range(len(TEMPORAIREY)):
if TEMPORAIREY[i]<mini:
mini=TEMPORAIREY[i]
moy=np.mean(agl) #calcul angle moyen
return(moy)
#_____________________________________________________________________________#
def dir_prin_imagerie(pos_fiss):
picture_generator(pos_fiss)
imm = Image.open('C:\\crack_simulator\\fichiers_temp\\screenfiss.png') # recuperer image
return(Traitement_Image(imm))
2
# trace generated using paraview version 5.8.0
#CECI EST LA MACRO TYPE
# To ensure correct image size when batch processing, please search
# for and uncomment the line `# renderView*.ViewSize = [*,*]`
#### import the simple module from the paraview

from paraview.simple import *
#### disable automatic camera reset on 'Show'
paraview.simple._DisableFirstRenderCameraReset()
# create a new 'XML Unstructured Grid Reader'

iSOVA0001vtu = XMLUnstructuredGridReader(FileName=['C:\\crack_simulator\\fichiers_temp\\ISOVA.0001.vtu'])
iSOVA0001vtu.CellArrayStatus = ['CONTRAINTE']
iSOVA0001vtu.PointArrayStatus = ['DEPLACEMENT']
# Properties modified on iSOVA0001vtu

iSOVA0001vtu.PointArrayStatus = []
# get active view

renderView1 = GetActiveViewOrCreate('RenderView')
# uncomment following to set a specific view size
# renderView1.ViewSize = [662, 484]
# get layout
layout1 = GetLayout()
# show data in view

iSOVA0001vtuDisplay = Show(iSOVA0001vtu, renderView1, 'UnstructuredGridRepresentation')
# trace defaults for the display properties.

iSOVA0001vtuDisplay.Representation = 'Surface'
iSOVA0001vtuDisplay.ColorArrayName = [None, '']
iSOVA0001vtuDisplay.OSPRayScaleFunction = 'PiecewiseFunction'
iSOVA0001vtuDisplay.SelectOrientationVectors = 'None'
iSOVA0001vtuDisplay.ScaleFactor = 0.30000000000000004
iSOVA0001vtuDisplay.SelectScaleArray = 'None'
iSOVA0001vtuDisplay.GlyphType = 'Arrow'
iSOVA0001vtuDisplay.GlyphTableIndexArray = 'None'
iSOVA0001vtuDisplay.GaussianRadius = 0.015
iSOVA0001vtuDisplay.SetScaleArray = [None, '']
iSOVA0001vtuDisplay.ScaleTransferFunction = 'PiecewiseFunction'
iSOVA0001vtuDisplay.OpacityArray = [None, '']
iSOVA0001vtuDisplay.OpacityTransferFunction = 'PiecewiseFunction'
iSOVA0001vtuDisplay.DataAxesGrid = 'GridAxesRepresentation'
iSOVA0001vtuDisplay.PolarAxes = 'PolarAxesRepresentation'
iSOVA0001vtuDisplay.ScalarOpacityUnitDistance = 0.12167685296727114
# reset view to fit data

renderView1.ResetCamera()
#changing interaction mode based on data extents

renderView1.InteractionMode = '2D'
renderView1.CameraPosition = [1.5, 0.5, 10000.0]
renderView1.CameraFocalPoint = [1.5, 0.5, 0.0]
# get the material library

materialLibrary1 = GetMaterialLibrary()
# update the view to ensure updated data information

renderView1.Update()
# set scalar coloring

ColorBy(iSOVA0001vtuDisplay, ('CELLS', 'CONTRAINTE', 'Magnitude'))
# rescale color and/or opacity maps used to include current data range
iSOVA0001vtuDisplay.RescaleTransferFunctionToDataRange(True, False)
# show color bar/color legend

iSOVA0001vtuDisplay.SetScalarBarVisibility(renderView1, True)
# get color transfer function/color map for 'CONTRAINTE'

cONTRAINTELUT = GetColorTransferFunction('CONTRAINTE')
# get opacity transfer function/opacity map for 'CONTRAINTE'

cONTRAINTEPWF = GetOpacityTransferFunction('CONTRAINTE')
# set scalar coloring

ColorBy(iSOVA0001vtuDisplay, ('CELLS', 'CONTRAINTE', 'SI11'))
# rescale color and/or opacity maps used to exactly fit the current data range
iSOVA0001vtuDisplay.RescaleTransferFunctionToDataRange(False, False)
# Update a scalar bar component title.

UpdateScalarBarsComponentTitle(cONTRAINTELUT, iSOVA0001vtuDisplay)
# hide color bar/color legend

iSOVA0001vtuDisplay.SetScalarBarVisibility(renderView1, False)
1
# Hide orientation axes
renderView1.OrientationAxesVisibility = 0
# Properties modified on cONTRAINTELUT

cONTRAINTELUT.RGBPoints = [-3425184256.0, 0.231373, 0.298039, 0.752941, 692672832.0, 0.705882, 0.0156863, 0.14902]


# Rescale transfer function

cONTRAINTELUT.RescaleTransferFunction(-28501706.0, 22215262.0)
# Rescale transfer function

cONTRAINTEPWF.RescaleTransferFunction(-28501706.0, 22215262.0)
# current camera placement for renderView1

renderView1.InteractionMode = '2D'
renderView1.CameraPosition = [1.5,0.1, 10000.0]
renderView1.CameraFocalPoint = [1.5,0.1, 0.0]
renderView1.CameraParallelScale = 0.1
# save screenshot
SaveScreenshot('C:/crack_simulator/fichiers_temp/screenfiss.png', renderView1, ImageResolution=[400, 400])
2
# -*- coding: utf-8 -*-
"""
Module progression fissure du projet MEF
"""
from math import atan2, sin

import random
import math
import re
#________________________________________________#
# lecture du .geo existant
def remaillage(fichiergeo,pforce,mesh,meshtip,p):
"""
-Fonction remaillage:
créer le maillage d'une fissure à partir des points clefs par lesqules elle passe'
ENTREE :
fichiergeo = fichier.geo dont le point n°1 le fond de fissure, et l'ensemble des points suivants
dans un ordre décrivant une boucle dans le sens horaire
pforce, le point d'application de la force'
SORTIE :
fichier.geo remaillé dans le même dossier
"""
ficR=open(fichiergeo,"r")
pointgeo=[]
x=[]
y=[]
for ligne in ficR:
r=re.search('^(.*)$(.*)$ *= *\{(.*)\};$',ligne)
if r:
if r[1]=='Point':
pointgeo.append([r[1],r[2],r.group(3).split(',')])
#ajout des deux derniers fond de fissure pour calculer les intersections
x=[(float(pointgeo[len(pointgeo)-1][2][0])+float(pointgeo[1][2][0]))*0.5,float(pointgeo[0][2][0])]
y=[(float(pointgeo[len(pointgeo)-1][2][1])+float(pointgeo[1][2][1]))*0.5,float(pointgeo[0][2][1])]
epsi=0.0001
# DDx=[float(pointgeo[len(pointgeo)-1][2][0])]
# GGx=[float(pointgeo[1][2][0])]
# DDy=[float(pointgeo[len(pointgeo)-1][2][1])]
# GGy=[float(pointgeo[1][2][1])]
DDx=[]
GGx=[]
DDy=[]
GGy=[]
for i in range(len(p)):
x.append(p[i][0])
y.append(p[i][1])
a=[]
b=[]
bd=[]
vertical=[]
horizon=[]
for i in range(len(x)-1):
if x[i+1]!=x[i]: #permet d'éviter les erreurs en cas de points vertical
if y[i+1]!=y[i]:
a.append( (y[i+1]-y[i])/(x[i+1]-x[i]) )
b.append( -(y[i+1]-y[i])/(x[i+1]-x[i]) * (x[i]-(epsi/(sin(atan2(y[i+1]-y[i],x[i+1]-x[i])))) ) + y[i] )
bd.append( -(y[i+1]-y[i])/(x[i+1]-x[i]) * (x[i]+(epsi/(sin(atan2(y[i+1]-y[i],x[i+1]-x[i])))) ) + y[i] )
else:
horizon.append(i)
a.append(0)
b.append(0)
bd.append(0)
else:
vertical.append(i)
a.append(0)
b.append(0)
bd.append(0)
def intersection(a,b,m,p):
X=(p-b)/(a-m)
Y=a*((p-b)/(a-m))+b
return([X,Y])
1
for i in range(0,len(x)-2):
if i in vertical:
DDx.append(x[i+1]+epsi)
GGx.append(x[i+1]-epsi)
DDy.append(y[i+1])
GGy.append(y[i+1])
elif i in horizon:
DDx.append(x[i+1])
GGx.append(x[i+1])
DDy.append(y[i+1]-epsi)
GGy.append(y[i+1]+epsi)
else:
DDx.append(intersection(a[i],bd[i],a[i+1],bd[i+1])[0])
DDy.append(intersection(a[i],bd[i],a[i+1],bd[i+1])[1])
GGx.append(intersection(a[i],b[i],a[i+1],b[i+1])[0])
GGy.append(intersection(a[i],b[i],a[i+1],b[i+1])[1])
if abs(x[i+1]-DDx[i])>=3*epsi:
print('error'+str(DDx[i])+'__'+str(x[i+1])+'__'+str(i))
DDx.pop(i)
GGx.pop(i)
DDy.pop(i)
GGy.pop(i)
DDx.append(x[i+1]+epsi)
GGx.append(x[i+1]-epsi)
DDy.append(y[i+1])
GGy.append(y[i+1])
## écriture du .geo
fic=open(fichiergeo,"w")
#écriture du nouveau fond de fissure
if y[len(y)-1]==1: ##évite de scinder le bloc complètement à la limite
fic.write('Point(1)={'+str(x[len(x)-1])+', '+str(y[len(y)-1]-epsi)+', 0, '+str(meshtip)+'};\n')
else:
fic.write('Point(1)={'+str(x[len(x)-1])+', '+str(y[len(y)-1])+', 0, '+str(meshtip)+'};\n')
#écriture des points

for i in range(len(GGx)):
fic.write('Point('+str(i+2)+')={'+str(GGx[len(GGx)-i-1])+', '+str(GGy[len(GGx)-1-i])+', 0, '+str(mesh)+'};\n')
n=i+2
for i in range(len(pointgeo)-1):
if float(pointgeo[i+1][2][0])==pforce[0] and float(pointgeo[i+1][2][1])==pforce[1]:
fic.write('Point('+str(n+i+1)+')={'+str(float(pointgeo[i+1][2][0]))+
', '+str(float(pointgeo[i+1][2][1]))+', 0, '+str(meshtip)+'};\n')
else:
fic.write('Point('+str(n+i+1)+')={'+str(float(pointgeo[i+1][2][0]))+
', '+str(float(pointgeo[i+1][2][1]))+', 0, '+str(mesh)+'};\n')
n=n+i+1
for i in range(len(DDx)):
fic.write('Point('+str(n+i+1)+')={'+str(DDx[i])+', '+str(DDy[i])+', 0, '+str(mesh)+'};\n')
n=n+i
### écriture des lignes
for i in range(n):
fic.write('Line('+str(i+1)+')={'+str(i+1)+', '+str(i+2)+'};\n')
fic.write('Line('+str(n+1)+')={'+str(n+1)+', 1};\n')
fic.write('Curve Loop(1) = { 1')
for i in range(1,n+1):
fic.write(', '+str(i+1))
fic.write('};\nPlane Surface(1) = {1};\nPhysical Surface("SURFT") = {1};')
fic.close()
2
1 * STRUCTURE EN DIMENSION 2, CALCUL DES CONTRAINTES PPRINCIPALES
2 * ----------------------------------------------------------------------------------
3 OPTI 'DIME' 2 MODE PLAN DEFO TRAC OPEN ;
4
5 * LECTURE DU MAILLAGE
6 TAB1= LIRE 'UNV' 'C:\crack_simulator\fichiers_temp\mesh.unv';
7 * OPTION D'ENREGISTREMENT CONTRAINTES PRINCIPALES
8 OPTI SORT 'C:\crack_simulator\fichiers_temp\CONTPRIN';
9
10 * CARACTERISTIQUES MATERIAU
11 * ------------------------------
12
13 RHO = 2500. ; COMM 'MASSE VOLUMIQUE [kg/m^3]';
14 YOUNG = 30.E9 ; COMM 'MODULE YOUNG [Pa (N/m2)]';
15 NU = 0.22 ; COMM 'COEFFICIENT POISSON [-]';
16
17 largeur=3.;
18 hauteur=1;
19 posforce=1.5;
20 posfiss=1.;
21 fissleng=0.1;
22 appuie=0.1;
23
24 A = posfiss fissleng;
25 A1 = (posfiss-0.05) (fissleng+0.05);
26 A2 = (posfiss-0.05) (fissleng-0.05);
27 A3 = (posfiss+0.05) (fissleng-0.05);
28
29 SURFT =(TAB1.'SURFT');
30
31
32 * MODELE MECANIQUE A MATERIAU CONSTANT
33 * ------------------------------------
34
35 MODSURF = MODE SURFT 'MECANIQUE' 'ELASTIQUE' 'ISOTROPE' ;
36 MATSURF = MATE MODSURF 'YOUN' YOUNG 'NU' NU;
37
38 * CALCUL DE LA MATRICE DE RAIDEUR
39 * -------------------------------
40
41 RIG1 = RIGI MODSURF MATSURF ; COMM matrice de rigidité;
42
43 * EXTRACTION DES POINTS DES CLs
44 * ---------------------------------------------
45
46 PFOR = posforce hauteur;
47 P1A = (largeur-appuie) 0.;
48 P2A = appuie 0.;
49
50 P1 = SURFT POIN 'PROC' P1A;
51 P2 = SURFT POIN 'PROC' P2A;
52
53 PFOR = SURFT POIN 'PROC' PFOR ;
54
55 * CONDITIONS AUX LIMITES : DEPLACEMENTS IMPOSES
56 * ---------------------------------------------
57
58 CL1 = BLOQ P1 'UX'; CL2 = BLOQ P1 'UY';
59 CL3 = BLOQ P2 'UX'; CL4 = BLOQ P2 'UY';
60 CL5 = BLOQ PFOR 'UY';
61 CLT = CL1 ET CL2 ET CL3 ET CL4 ET CL5 ;
62
63 RIG1 = RIG1 ET CLT ;
64
65 D1 = DEPI CL5 -0.001;
66
67
68 * CALCUL DU CHAMP DE DEPLACEMENT
69 * ------------------------------
70
71 DEPLA = RESO RIG1 D1;
72
73 * POST TRAITEMENT
74 * ---------------
75
76 SIGBET = SIGM DEPLA MODSURF MATSURF ;
77 TP1 = PRIN SIGBET MODSURF; COMM matrice de containtre PRIN;
78
79
80 * SAUVEGARDE DES OBJETS CREES
81 * ---------------------------
82
83 SORT 'AVS' TP1 ;
84
85 OPTI SORT 'C:\crack_simulator\fichiers_temp\ISOVA';
86 SORT 'VTK' SURFT 'MAILLAGE'
87 DEPLA 'DEPLACEMENT'
88 TP1 'CONTRAINTE' ;
89
90 FIN;
91
92

Rapport MEF Depieds Le-Goff Cuisset1

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Rapport MEF Depieds Le-Goff Cuisset1

Transféré par

Droits d'auteur :

Formats disponibles

2

Projet méthode éléments finis — MI4

Polytech Montpellier — Université Montpellier

Prédiction de propagation de fissure par la

2 Etude des fissures

2.1 Recherche appliquée : application au génie civil

Il existe également des classifications de fissures en fonction de leur apparence externe[3] :

Plusieurs cas sont illustrés "Figure 1".

Fig. 1: Faiençage - Fissure - Fracture

2.2 Recherche fondamentale : génie mécanique

Fig. 3: Lien entre triaxialité, déformation et contrainte à rupture

2.2.2 Approche Cinématique et modes de propagation

Fig. 4: Modes de propagation de fissure - Approche cinématique

Fig. 5: Défaut elliptique au sein d’une structure solicitée en mode I

2.2.3 Bilan des méthodes existantes

Fig. 6: Contrainte σθ en fonction de la distance à la pointe de fissure

3 Méthode de prédiction de propagation de fissure

Les données nécessaires pour l’application de la méthode sont :

- Les chargements extérieurs appliqués à la structure.

La première étape est la détermination de la direction de propagation de fissure.

Dans le cadre d’une méthode de simulation à critère énergétique

Fig. 7: Propagation d’une fissure en mode I pur

L’objectif de la méthode développée dans ce rapport est de déterminer l’orientation de la direction de

Fig. 8: Méthode de détermination des noeuds candidats

4.1 Cadre d’application

Fig. 9: Problème flexion trois points à fissure décentrée

Cette modélisation du problème offre deux avantages majeurs :

4.1.2 Béton utilisé, composition

Fig. 10: Composition du matériau simulé : Béton

4.2 Hypothèses : récapitulatif

5 Méthode éléments finis

5.1 Structure du programme

Fig. 11: Structure globale du programme

5.2 Création de la géométrie initiale via GMSH et maillage

5.3 Calcul des contraintes via Cast3m

La résolution numérique s’effectue en plusieurs étapes :

- La quatrième étape est la résolution de l’équation : div(σ) + F = 0 , permettant de calculer le champ

Fig. 12: Contenu du fichier au format .inp

6 Traitement des données

6.2 Détermination de la direction de propagation de fissure

Fig. 13: Premières idées illustrées

6.3 Recherche du plan de symétrie

La "Figure 14" représente très nettement la forme décrite.

Fig. 14: Forme d’ailes de papillon observées en pointe de fissure

6.3.1 Segmentation en sous-domaines

La division de la plaque en sous-domaines circulaires est illustrée "Figure 15".

Fig. 15: Schématisation des sous-domaines d’observation

6.3.2 Méthode directe

Fig. 16: Position du point de Gauss au sein d’un trièdre

Fig. 17: Directe - Sous-domaine d’étude et détermination du creux, étape 1

Fig. 18: Directe - Sous-domaine d’étude et détermination du creux, étape 2

La détermination de la direction de propagation n’est cependant pas terminée. En effet, la méthode

6.3.3 Méthode par imagerie

Fig. 19: Zone délimitant le voisinage d’une pointe de fissure

Fig. 20: Imagerie des iso-contraintes σI

de fissure et suivant la courbe d’iso-contrainte, formant deux ailes de papillon.

Finalement la solution suivante a été retenue :

Fig. 22: Imagerie - Domaine d’observation

Fig. 23: Imagerie - Valeurs de seuils testés

Fig. 24: Imagerie - Résultat

Fig. 25: Toy Model - Version 1

Fig. 26: Toy-Model - Version finale

8 Progression de la fissure et remaillage

Fig. 27: Création de la nouvelle géométrie

pb=[epscos(alpha)+po[0],epssin(alpha)+po[1]] #point B sens de propagation avec angle alpha