u4.51.04 Opérateur MECA_NON_LINE#

Résumé :

Calculer l’évolution mécanique ou thermo-hydro-mécanique couplée, en quasi-statique ou en dynamique, d’une structure en non linéaire.

La non-linéarité est liée soit au comportement du matériau (par exemple plastique), soit à la géométrie (par exemple en grands déplacements) soit au contact-frottement.

Pour avoir des détails sur la méthode de résolution employée, on se reportera aux documentations de référence [R5.03.01] et [R5.05.05].

L’évolution peut être étudiée en plusieurs travaux successifs (concept ré-entrant), soit en poursuite (le dernier instant calculé est l’instant initial du calcul suivant), soit en reprise en partant d’un instant antérieur.

Produit une structure de données de type evol_noli.

Avertissement

Cette documentation est provisoire, l’opérateur ne peut pas être utilisé dans les études AIP et il est hors du périmètre de qualification.

Contenu de la structure de données EVOL_NOLI#

La structure de données EVOL_NOLI contient la liste des champs archivés au cours du calcul (selon les différentes options de mot-clef ARCHIVAGE). Par défaut, elle contient, pour chaque instant, la liste des champs suivants:

DEPL: champ (aux nœuds) des déplacements;
SIEF_ELGA: champ (aux points de Gauss) des contraintes;
VARI_ELGA: champ (aux points de Gauss) des variables internes;
COMPORTEMENT: carte du comportement. Cette carte contient des informations sur le comportement non-linéaire utilisé, elle n’est pas lisible lorsqu’on l’imprime au format MED.

En plus de ces champs, la structure de données contient également des paramètres. À chaque instant, on stocke au minimum:

Nom	Mot-clef origine	Description	Type
INST		Valeur de l’instant de calcul	R
EXCIT	EXCIT	Informations sur les chargements	K24
MODELE	MODELE	Modèle	K8
CARAELEM	CARA_ELEM	Caractéristiques élémentaires	K8
CHAMPMAT	CHAM_MATER	Champ de matériau	K8

Paramètres généraux#

Les paramètres généraux décrivent le modèle, le champ des matériaux et les caractéristiques élémentaires (en particulier pour les éléments de structure).

MODELE est le nom du modèle dont les éléments font l’objet du calcul mécanique. La structure de données vient de la commande [U4.41.01]. Il est toujours obligatoire.

CHAM_MATER est le nom du champ de matériau affecté sur le modèle. La structure de données vient de la commande [U4.43.01]. Toutes les mailles principales du modèle doivent être associées à un matériau.

CARA_ELEM est le nom des caractéristiques des éléments de coque, poutre, tuyau, barre, câble, et éléments discrets affectés sur le modèle. La structure de données vient de la commande [U4.42.01]. Évidemment, ce mot-clé est optionnel: si le modèle ne contient pas de tels éléments, il n’est pas utile; en revanche, si le modèle contient de tels éléments, il est obligatoire.

Paramétrisation du calcul#

Le calcul non-linéaire est résolu par une méthode incrémentale, il est donc nécessaire de paramétrer le calcul. On utilise pour ça la variable temps (notée INST), même s’il n’a pas de sens physique en statique. La discrétisation (pseudo)-temporelle est géré par le mot-clef facteur INCREMENT qui va définir les intervalles de temps pris dans la méthode incrémentale.

Remarque: Les instants ainsi définis n’ont de sens physique que pour des relations de comportement où le temps intervient explicitement (visco-élastiques ou visco-plastiques par exemple). Dans les autres cas, ils permettent seulement d’indicer les incréments de charge et de paramétrer l’évolution d’un éventuel champ de température.

Définition générale de la liste d’instants#

Pour renseigner la liste d’instant, il y a deux manières de faire. La première est directe: on donne la liste d’instants par le mot-clef LIST_INST. Cette liste est donnée par l’opérateur [U4.34.01]. Cette manière de faire ne donne pas accès aux fonctionnalités avancées de gestion automatique de la liste d’instants. Elle est n’est donc pas recommandée.

On peut définir les instants de calcul par l’opérateur [U4.34.03] et gérer simultanément la découpe automatique du pas de temps et d’autres fonctionnalités avancées. C’est la manière recommandée de faire.

Il faut également rappeler que, par convention, l’instant initial du calcul d’un calcul vierge (sans reprise) est désigné par le numéro d’ordre 0. Par ailleurs, les numéros d’ordre sont forcément croissants et sans « trous ».

Gestion des reprises#

Si on ne précise rien, le calcul sera réalisé sur tous les instants définis par LIST_INST. Il est possible de gérer plus finement cette liste. L’instant initial du calcul (qui donc n’est pas (re)calculé) est désigné soit par sa valeur (INST_INIT), soit par son numéro d’ordre dans la liste d’instants litps (NUME_INST_INIT).

En l’absence des mots clés INST_INIT ou NUME_INST_INIT, le défaut est NUME_INST_INIT=0.

L’instant final (dernier pas calculé) est désigné de la même manière que l’instant initial (soit NUME_INST_FIN, soit INST_FIN), sauf qu’il n’est pas possible de faire référence à l’instant de l’état initial.

Remarques

Si le redécoupage automatique du pas de temps est activé, NUME_INST_FIN n’en tient pas compte et travaille toujours sur la liste d’instants initial. NUME_INST_INIT et NUME_INST_FIN ne sont actifs qu’à l’initialisation.
La liste d’instants étant strictement croissante, il peut arriver que certains pas de temps ne soient pas archivés bien que demandés. Par exemple, dans le cas d’une reprise de calcul. Si le calcul en reprise d’un calcul précédent n’a aucun instant supérieur à la première * phase de calcul, aucun pas de temps ne sera archivé.

A - Exemple simple (comportement par défaut)

listInst = DEFI_LIST_REEL(DEBUT=0.,
                          INTERVALLE=_F(JUSQU_A= 10.,NOMBRE=10)),
evolNoli = MECA_NON_LINE(INCREMENT=_F(LIST_INST=listInst,
                         INST_FIN=4.)),
evolNoli = MECA_NON_LINE(reuse=evolNoli,
                         INCREMENT=_F(LIST_INST=listInst),
                         ETAT_INIT=_F(EVOL_NOLI=evolNoli))

Le premier MECA_NON_LINE effectue le calcul pour les instants 1, 2, 3 et 4.

Le second MECA_NON_LINE: effectue le calcul pour les instants 5, 6, 7, 8, 9 et 10, l’état initial correspondant au temps 4.

B - Exemple pour montrer l’intérêt de INST_INIT

listInst = DEFI_LIST_REEL(DEBUT=0.,
                          INTERVALLE=_F(JUSQU_A= 10.,NOMBRE=10)),
evolNoli = MECA_NON_LINE(INCREMENT=_F(LIST_INST=listInst,
                         INST_FIN=4.)),
evolNoli = MECA_NON_LINE(reuse=evolNoli,
                         INCREMENT=_F(LIST_INST=listInst,
                         INST_INIT=8.),
                         ETAT_INIT=_F(EVOL_NOLI=evolNoli))

Premier MECA_NON_LINE: effectue le calcul des instants 1 à 4.

Second MECA_NON_LINE: effectue le calcul pour les instants 9 et 10 (on ne fait rien pour \(t=5,6,7\) et 8), l’état initial correspondant au temps 4.

Sélection des instants#

Les instants dans MECA_NON_LINE sont repérés par un numéro d’ordre (un entier). Si l’utilisateur veut utiliser un instant (un réel) et non un numéro d’ordre pour la sélection, les mots-clefs PRECISION et CRITERE permettent d’identifier ce numéro d’ordre (voir [U4.71.00] pour la syntaxe détaillée)

Ces paramètres servent à repérer le bon numéro d’ordre (NUME_INST_FIN/NUME_INST_INIT) quand l’utilisateur renseigne l’instant (INST_FIN/INST_INIT).

Soit la liste d’instant suivante:

NUME	1	2	3	4	5	6	7
INST	0.0010	0.0020	0.0030	0.0040	0.0050	0.0060	0.0070

Si l’utilisateur veut sélectionner l’instant correspondant à NUME=4, il lui suffit de dire INST=0,0040.

Prenons un autre exemple

NUME	1	2	3	4	5	6	7
INST	0.10000001	0.10000002	0.10000003	0.10000004	0.10000005	0.10000006	0.10000007

Si l’utilisateur veut sélectionner l’instant correspondant à NUME=4, il ne lui suffit pas de dire INST=0,10000004, car l’écart relatif entre les instants vaut \(\frac{0,10000005-0,10000004}{0,10000004}=1,0\times 10^{-7}\) qui est inférieur à la valeur de précision par défaut (\(1,0\times 10^{-6}\) ). On ne pourra donc pas distinguer NUME=3, 4 et 5 (le code s’arrête alors en erreur fatale). Il suffit alors de changer le paramètre PRECISION pour pouvoir sélectionner l’instant (dans notre exemple, PRECISION=1E-8 conviendra).

Réglages des solveurs non-linéaires#

Choix de la méthode#

Il existe trois grandes catégories de solveurs non-linéaires accessibles:

la méthode de Newton (et ses variantes) ;
les solveurs non-linéaires appelés SNES (Scalable Nonlinear Equations Solvers) de la librairie PETSC ;
le solveur RASPEN (Restricted Additive Schwarz Preconditioned Exact Newton) qui est fondé sur une approche de décomposition de domaines non-linéaires.

Le solveur est sélectionné par le mot-clef METHODE.

Méthode de Newton et ses variantes#

Quand METHODE= »NEWTON », on utilise l’algorithme de Newton-Raphson pour résoudre le problème (voir [R5.03.01]).

C’est le mot-clef facteur NEWTON (une seule occurrence) qui permet de régler les différents paramètres.

La phase de prédiction (Cf. [R5.03.01]) a pour but de calculer une estimation du champ de déplacements afin de permettre à la méthode de Newton de converger plus rapidement. Losque le mot clé est absent, c’est la matrice tangente en vitesse (option RIGI_MECA_TANG) qui est utilisée si l’on a choisi pour la méthode de Newton une PREDICTION=”TANGENTE”, et c’est la matrice élastique (option RIGI_MECA) qui est utilisée si on a choisi PREDICTION=”ELASTIQUE”.

Le mot-clef REAC_INCR=mf permet de contrôler la fréquence de réactualisation de la matrice par rapport aux pas de temps.

Remarques

Si la matrice utilisée en prédiction correspond au calcul élastique, elle n’est évaluée qu’une fois à l’instant initial, en début d’algorithme, sauf si les caractéristiques élastiques dépendent du temps ou d’une variable de commande comme la température qui dépend du temps
Cette matrice « élastique » est calculée en utilisant le module d’Young donné sous le mot clé ELAS de l’opérateur [U4.43.01], et non pas la pente à l’origine de la courbe de traction donnée sous le mot clé TRACTION (et qui sert, elle, dans l’expression des relations de comportement VMIS_ISOT_TRAC, VMIS_ECMI_TRAC et VISC_ISOT_TRAC)

La matrice utilisée pour les itérations globales de la méthode est la matrice tangente (consistante) [R5.03.01] si MATRICE=”TANGENTE” ou la matrice élastique si MATRICE=”ELASTIQUE”.

Le mot-clef REAC_ITER=it permet de contrôler la fréquence de réactualisation de la matrice par rapport aux itérations de Newton. Donc à la première itération de Newton, on ne réassemble la matrice tangente que si it vaut 1: sinon on garde la matrice utilisée dans la phase de prédiction. Par convention si it vaut 0 la matrice n’est pas réévaluée durant tout le pas de temps.

Méthode `SNES`#

Quand METHODE= »SNES », on fait appel au solveur non-linéaire SNES de la librairie PETSC. Il s’agit d’une implantation très générique de nombreux solveurs différents allant de la méthode de Newton classique, à la méthode BFGS ou la méthode de Picard ainsi que toutes les combinaisons possibles de ces dernières (voir [bib1]). Le paramétrage se fait par une liste d’options transmises sous forme de chaines de caractères par le mot-clé OPTION_PETSC du mot-clé facteur SOLVEUR (voir [U4.50.01]). Son usage est réservé aux utilisateurs avancés.

Méthode `RASPEN`#

La méthode RASPEN est fondée sur une méthode de décomposition de domaine non-linéaire. Elle est uniquement utilisable dans le contexte HPC. Elle s’appuie sur 2 niveaux de solveurs non-linéaires :

un niveau local, où un problème non-linéaire est résolu sur chaque sous-domaine, sans communication avec ses voisins et donc de manière parallèle et asynchrone ;
un niveau global, qui exploite les résolutions locales précédentes pour faciliter la résolution du problème considéré.

Comme pour la méthode SNES, le paramétrage se fait par une liste d’options transmises sous forme de chaines de caractères par le mot-clé OPTION_PETSC du mot-clé facteur SOLVEUR. Les options qui concernent le solveur local sont préfixées par lsnes_ tandis que les options qui concernent le solveur global sont préfixées par gsnes_. On peut commodemment définir ces options comme suit :

myOptions = (
    # local snes
    "-prefix_push lsnes_ "
    + "-snes_monitor -snes_linesearch_type basic -snes_rtol 1.e-8 -snes_atol 1.e-50 -snes_max_it 5  "
    + "-ksp_type preonly  -pc_type lu -pc_factor_mat_solver_type mumps "
    + "-prefix_pop "
    # global snes
    + "-prefix_push gsnes_  "
    + "-snes_linesearch_type basic -ksp_monitor -ksp_rtol 1.e-7 -ksp_atol 1.e-50  -snes_max_it 20  "
    + "-prefix_pop "
)

La première ligne exprime le fait que l’on va paramétrer le solveur non-linéaire local à chaque sous-domaine appelé « lsnes » (« l » pour local, « snes » pour Scalable Nonlinear Equations Solvers). Ensuite, on exprime que l’on veut monitorer le solveur non linéaire local qui est par défaut la méthode de Newton ; on précise que la recherche linéaire n’est pas utilisée (basic signifie que l’on utilise un pas de 1.) et on donne les critères de convergence relatif et absolu ainsi que le nombre maximal d’itérations. Ensuite on exprime que l’on souhaite utiliser le solveur MUMPS pour résoudre les problèmes linéarisés. On fait ensuite de même pour le solveur non-linéaire global appelé « gsnes ».

Pour toute précision, le lecteur est renvoyé vers [bib2]. Son usage est réservé aux utilisateurs avancés.

Recherche linéaire#

La recherche linéaire peut permettre d’améliorer la convergence de la méthode de Newton (Cf.[R5.03.01] pour plus de détails).

Remarque:: Il est déconseillé d’utiliser la recherche linéaire avec les déformations GROT_GDEP, pour les modélisations COQUE_3D et en présence de contact.

Ce mot-clef permet de choisir la méthode de recherche linéaire, c’est-à-dire l’algorithme de recherche du zéro de la fonctionnelle (voir [R5.03.01]). La méthode est une méthode sécante unidimensionnelle.

Les paramètres ITER_LINE_MAXI=itelin et RESI_LINE_RELA=reslin sont les paramètres de la recherche linéaire. On donne le nombre d’itérations maximum itelin à effectuer et la précision reslin à atteindre pour réaliser la convergence de la recherche linéaire.

Les mots-clés RHO_MIN, RHO_MAX et RHO_EXCL fixent l’intervalle \(I\) dans lequel on calcule le coefficient \(\rho\): de la recherche linéaire, sous la forme

\[I=[\rho_{min},\rho_{max}]-[-\rho_{exc},\rho_{exc}]\]

Réglages de la convergence#

Le mot-clef facteur CONVERGENCE permet de contrôler les paramètres de convergence du calcul.

Le mot-clef ITER_GLOB_MAXI donne le nombre d’itérations maximum effectué pour résoudre le problème global à chaque instant. L’augmentation excessive de ce paramètre est généralement le signe d’un problème dans la modélisation ou d’une discrétisation temporelle inadéquate.

Il existe deux critères de convergence: RESI_GLOB_RELA en relatif et RESI_GLOB_MAXI en absolu. Si on ne renseigne rien, alors tout se passe comme si RESI_GLOB_RELA = 1.E-6.

Pour RESI_GLOB_MAXI=resmax, l’algorithme continue les itérations globales tant que

\[\underset{i=1, \dots , \mathrm{nbddl}}{\max} {F}^{n} > \text{resmax}\]

où \({F}^{n}\) est le résidu de l’itération n (Cf. [R5.03.01] pour plus de détails). Si cet opérande est absent, le test n’est pas effectué.

Pour RESI_GLOB_RELA=resrel, l’algorithme continue les itérations globales tant que:

\[\underset{i=1, \dots , \mathrm{nbddl}}{\max} {F}^{n} > \text{resrel} . {\max} L\]

où \(L\) est le vecteur du chargement imposé et des réactions d’appuis (Cf. [R5.03.01] pour plus de détails).

Lorsque le chargement et les réactions d’appui deviennent nuls, c’est-à-dire lorsque \(L\) est nul (par exemple dans le cas d’une décharge totale), RESI_GLOB_RELA est affiché à -1, et on essaie de passer du critère de convergence relatif RESI_GLOB_RELA au critère de convergence absolu RESI_GLOB_MAXI. Cette opération est transparente pour l’utilisateur (message d’alarme émis dans le fichier .mess). Lorsque le vecteur \(L\) redevient différent de zéro, on repasse automatiquement au critère de convergence relatif RESI_GLOB_RELA.

Toutefois, ce mécanisme de basculement ne peut pas fonctionner au premier pas de temps. En effet, pour trouver une valeur de RESI_GLOB_MAXI raisonnable de manière automatique (puisque l’utilisateur ne l’a pas renseigné), on a besoin d’avoir eu au moins un pas convergé sur un mode RESI_GLOB_RELA . Dès lors, si le chargement est nul dès le premier instant, le calcul s’arrête. L’utilisateur doit déjà alors vérifier que le chargement nul est normal du point de vue de la modélisation qu’il réalise, et si tel est le cas, trouver un autre critère de convergence (RESI_GLOB_MAXI par exemple).

Si RESI_GLOB_RELA et RESI_GLOB_MAXI sont présents tous les deux, les deux tests sont effectués.

Critères de convergence avancés#

Le critère RESI_REFE_RELA \(\varepsilon_{refe}\) conduit à estimer la convergence de l’algorithme de Newton de la manière suivante. A partir d’une référence, qui peut être:

Une contrainte SIGM_REFE
Une déformation EPSI_REFE pour des éléments incompressibles, des éléments de grille et de membrane;
Une variable interne VARI_REFE si l’on utilise des lois non locales à gradient de déformation;
Un flux thermique FLUX_THER_REFE dans un cas THM;
Deux flux hydriques FLUX_HYD1_REFE et FLUX_HYD2_REFE dans un cas HHM;
Un déplacement DEPL_REFE si on utilise des éléments de joint avec un comportement de type CZM;
Une force EFFORT_REFE et un moment MOMENT_REFE si on utilise des éléments de structure (discrets, barres, poutres ou câbles);
Une force linéique EFFORT_REFE et un moment linéique MOMENT_REFE si on utilise des éléments de structure 2D (plaques et coques);

On calcule une référence de résidu \({F}^{\mathit{ref}}\) (un vecteur de même longueur que le vecteur résidu). La convergence sera réalisée si et seulement si:

\[\forall i \in [1, \dots, \mathit{nbddl} ] \mid {F}_{i}^{n}\mid < \varepsilon_{refe} \, {F}_{i}^{\mathit{ref}}\]

EFFORT_REFE et MOMENT_REFE n’attendant pas des valeurs de même dimension pour les éléments de structure 1D et 2D, il est fortement déconseillé d’utiliser ce critère de convergence sur un modèle comportant ces deux types d’élément.

Réglages du solveur linéaire#

Le mot-clef facteur SOLVEUR permet de choisir les options utilisées par le solveur linéaire.

La syntaxe de ce mot clé commun à plusieurs commandes est décrite dans le document [U4.50.01].

Comportements non-linéaires#

Les comportements non-linéaires sont décrit par le mot-clef facteur répétable COMPORTEMENT. La syntaxe de ce mot-clé commun à plusieurs commandes est décrite dans le document [U4.51.11].

Reprises, archivage et gestion de l’état initial#

Dans le cas où l’on souhaite poursuivre un calcul déjà exécuté, le mot-clef RESULTAT indique quel objet est enrichi.

Définition d’un état initial#

Le mot-clef ETAT_INIT permet de définir un état initial de référence. Dans le cas où l’utilisateur a spécifié que le concept résultat est réentrant (par le mot RESULTAT), le mot-clé ETAT_INIT est obligatoire. Par convention, l’état initial d’un calcul vierge (sans reprise) est stocké au numéro d’ordre 0.

Par défaut (si on ne précise rien) tous les champs sont identiquement nuls. L’état initial peut être défini soit en précisant chaque champ de l’état initial, soit en extraction depuis un concept de type evol_noli préexistant.

Si on donne une structure de données de type EVOL_NOLI=evol provenant d’un autre calcul par le mot-clef EVOL_NOLI, on extrait automatiquement les champs de cette structure de données pour l’état initial.

L’extraction de l’état mécanique initial dans la structure de données evol_noli se fait à partir du numéro d’archivage NUME_ORDRE ou de l’instant d’archivage INST.

Si NUME_ORDRE ou INST ne sont pas remplis, on prend le dernier numéro archivé existant. Ces champs extraits seront archivés au premier instant de la liste d’instants défini sous le mot-clé INCREMENT. Dans le cas où l’on renseigne INST, les mots-clefs PRECISION et CRITERE (voir [U4.71.00] pour la syntaxe détaillée) servent à repérer le bon numéro d’ordre. En effet, les instants sont repérés par un numéro d’ordre (un entier). Si l’utilisateur veut utiliser un instant (un réel) et non un numéro d’ordre pour INST, l’opérande PRECISION permet de sélectionner ce numéro d’ordre.

A - Exemple simple (comportement par défaut)

listInst = DEFI_LIST_REEL(DEBUT=0.,
                          INTERVALLE=_F(JUSQU_A= 10.,NOMBRE=10)),
evolNoli = MECA_NON_LINE(INCREMENT=_F(LIST_INST=listInst,
                         INST_FIN=4.)),
evolNoli = MECA_NON_LINE(reuse=evolNoli,
                         INCREMENT=_F(LIST_INST=listInst),
                         ETAT_INIT=_F(EVOL_NOLI=evolNoli))

Le premier MECA_NON_LINE effectue le calcul pour les instants 1, 2, 3 et 4.

Le second MECA_NON_LINE: effectue le calcul pour les instants de 5 à 10, l’état initial correspondant au temps 4.

B - Exemple pour montrer l’intérêt de deux listes d’instants différentes

listInst1 = DEFI_LIST_REEL(DEBUT=0.,
                           INTERVALLE=_F(JUSQU_A= 10., NOMBRE=10)),

evolNoli = MECA_NON_LINE (INCREMENT=_F(LIST_INST=listInst1))

listInst2 = DEFI_LIST_REEL(DEBUT=20.,
                           INTERVALLE=_F(JUSQU_A= 30., NOMBRE=10))

evolNoli = MECA_NON_LINE(reuse=evolNoli,
                         RESULTAT=evolNoli,
                         INCREMENT=_F(LIST_INST=listInst2, INST_INIT=20.),
                         ETAT_INIT=_F(EVOL_NOLI=evolNoli,))

Le premier MECA_NON_LINE effectue le calcul pour les instants de 1 à 10. L’état initial, de numéro d’ordre 0, est vierge (tous les champs sont nuls).

Le second MECA_NON_LINE effectue le calcul des instants 21 à 30. L’état initial correspond à l’instant 10 du premier MECA_NON_LINE (dernier instant calculé dans le premier MECA_NON_LINE). Cet état initial correspond pour ce second MECA_NON_LINE à l’instant 20 (INST_INIT=20.).

L’utilisation d’un état initial non nul va changer le calcul de la déformation thermique. S’il y a un état initial non nul, alors le calcul de la déformation thermique est incrémental pur.

Si on utilise un état initial dont le modèle est différent du modèle de calcul renseigné dans l’opérateur, on procède automatiquement au passage entre les deux modèles:

Si le modèle de calcul est inclus dans le modèle donné dans l’état initial, les données de l’état initial sont simplement recopiées maille à maille pour tous les champs
Si le modèle donné dans l’état initial est inclus dans le modèle de calcul, on commence par copier les valeurs de l’état initial pour les mailles communes puis complète avec la valeur nulle. Il faut prendre garde au sens que peut avoir une variable interne nulle initiale dans le calcul

Les mots-clefs DEPL, SIGM et VARI permettent (respectivement) de donner un champ de déplacement, de contraintes et de variables internes initiaux. Si l’un de ces champs n’est pas précisé, il est pris nul par défaut. Ils peuvent par exemple être issus de la commande CREA_CHAMP [U4.72.04], ou bien avoir été lus dans un fichier par la commande LIRE_RESU [U7.02.01].

Le champ de contraintes et de variables internes aux points de Gauss et le champ des déplacements est un champ aux nœuds. Si les champs ne sont pas définis sur les bons supports les conversions peuvent être faites de manière automatique. Il n’y a aucune condition imposée sur les champs données par l’utilisateur. Ils peuvent très bien représenter un état mécanique non-équilibré et/ou ne respectant pas la loi de comportement. Si le calcul a du mal à converger dans ce cas, le plus simple est de créer artificiellement un état de contraintes initiales nul pour forcer la sélection du mode incrémental, ou d’utiliser une matrice purement élastique, qui permet une convergence certaine au prix d’un grand nombre d’itérations.

En grandes déformations, l’utilisateur souhaitant utiliser le formalisme GDEF_LOG avec un champ de contrainte initial (ETAT_INIT) se reportera au cas test SSNP159b. En effet, pour imposer un champ de contrainte initial, l’utilisateur doit donner en entrée le tenseur de contrainte défini dans l’espace logarithmique \(T\) (et non celui de Cauchy \(\sigma\) ). Les composantes de ce dernier étant stockées en tant que variables internes, il faut utiliser le mot-clef VARI.

Si les caractéristiques matériaux dépendent fortement des variables de commande, il convient d’être prudent sur la sélection de l’état initial, au risque de ne pas converger. En effet, les comportements élastiques existent en deux versions (voir [U4.51.11]). La version élastique « pure » est choisie automatiquement par le code lorsqu’il n’y a pas d’état initial, sinon, on sélectionne la version incrémentale. Or, seule cette dernière est efficace si l’on a de fortes variations des caractéristiques matériaux (élastiques dans ce cas) par rapport aux variables de commande.

Si on utilise simultanément un état provenant d’un résultat complet (mot-clef EVOL_NOLI) et la définition individuelle d’un champ (par exemple les contraintes), la règle de surcharge s’applique et les champs données à titre individuel remplacent ceux présents dans la structure de données donnée comme état initial.

Archivage des résultats#

Le mot-clef facteur ARCHIVAGE (une seule occurrence) permet d’archiver des ou certains résultats à tous ou certains instants du calcul.

En l’absence de ce mot clé tous les pas de temps sont archivés, y compris les instants de calculs nouvellement créés par redécoupage automatique du pas de temps. L’archivage permet de réduire sensiblement la taille des bases en sélectionnant les instants sauvegardés.

La désignation des instants à stocker est effectuée soit par une liste d’instants (mots-clefs LIST_INST ou INST) ou alors par une fréquence d’archivage PAS_ARCH=npas (tous les npas de temps).

Remarques

le dernier pas de calcul est toujours stocké pour pouvoir effectuer une reprise
si on emploie un accès par liste d’instants, alors les instants de calculs nouvellement créés par redécoupage automatique du pas de temps ne seront pas archivés
l’état initial est systématiquement archivé sous le numéro d’ordre 0 dès lors que l’on n’est pas en reprise de calcul

Le mot-clef CHAM_EXCLU permet de préciser les champs qui ne seront pas archivés, excepté au dernier pas de temps.

Chargements#

◇ EXCIT = _F(
      ◆ CHARGE = char_cine_meca / char_meca,
      ◇ FONC_MULT = fonction / formule / nappe,
      ◇ TYPE_CHARGE = / "DIDI",
                      / "FIXE_CSTE" (par défaut),
  ),

Principes généraux#

Le mot clé facteur EXCIT permet de décrire à chaque occurrence une charge (sollicitations et conditions aux limites), et éventuellement un coefficient multiplicateur et/ou un type de charge.

Le calcul non-linéaire est résolu par une méthode incrémentale, il est donc nécessaire de paramétrer le calcul. On applique donc les chargements de manière incrémentale également, par exemple, en appliquant la force de manière progressive (une rampe). Le principe de base est de séparer la partie spatiale du chargement et la partie (pseudo)-temporelle .

\[\underline{L}_{ext} \left ( {\underline{u}, t} \right ) = g \left ( t \right ) \underline{L}_{ext} \left ( \underline{u} \right )\]

La partie spatiale du chargement \(\underline{L}_{ext} \left ( \underline{u} \right )\) est donnée par le mot-clef CHARGE (comportant éventuellement l’évolution d’un champ de température) .

Remarques

Dans un calcul thermo-mécanique, si la température initiale est différente de la température de référence (donnée dans [U4.43.01]), le champ de déformation associé à l’instant initial peut être incompatible et donc conduire à un état de contraintes et de variables internes associé non nul. Si l’on utilise une relation de comportement incrémentale et si on ne définit pas explicitement un état de contraintes et de variables internes initial (associé à un champ de température initiale différente de la température de référence), le champ de contraintes et de variables internes calculé au premier incrément ne tiendra compte que de la seule variation de température entre l’instant initial et le premier instant, et non des éventuelles contraintes de compatibilité associées à la température initiale. Pour prendre cet état initial en compte, il faut le donner explicitement, par exemple grâce aux mots clés dans ETAT_INIT. Pour éviter de telles situations qui peuvent conduire à des erreurs de calculs, il vaut mieux commencer un calcul en considérant qu’il faut partir d’un état vierge.
Si on réalise un calcul en axisymétrique et que l’on impose des forces nodales, ces efforts doivent être divisés par \(2\pi\) (on travaille sur un secteur d’un radian) par rapport aux chargements réels. De même, si l’on souhaite calculer la résultante des efforts, le résultat est à multiplier par \(2\pi\) pour avoir la résultante totale sur la structure complète. De même en contraintes planes ou en déformation plane, on travaille sur une épaisseur unité: les efforts (sur l’épaisseur) appliqués doivent être divisés par l’épaisseur, les efforts réels sont obtenus en multipliant par l’épaisseur les efforts du calcul.

La partie temporelle du chargement \(g \left ( t \right )\) est donnée par le mot-clef FONC_MULT. Si on ne précise pas la fonction multiplicatrice, on applique une fonction échelon.

Il est possible de définir directement \(\underline{L}_{ext} \left ( {\underline{u}, t} \right )\) dans le mot-clef CHARGE si on utilise la commande AFFE_CHAR_MECA_F (fonction du temps). Dans ce cas, il faut être prudent: en effet, si on utilise en même temps FONC_MULT, on multiplie de nouveau le chargement par une fonction du temps.

Par défaut, TYPE_CHARGE vaut “FIXE_CSTE”: cela correspond à un chargement appliqué sur la géométrie initiale et non piloté. Il peut cependant être une fonction, et, en particulier, dépendre du temps. Un chargement fixe n’est réévalué qu’à chaque nouvel instant, et seulement s’il dépend du temps (défini dans [AFFE_CHAR_MECA_F] et paramétré par l’instant ou bien affecté par FONC_MULT).

Chargements incrémentaux#

Si TYPE_CHARGE=”DIDI” alors les conditions de Dirichlet (déplacements imposés, conditions linéaires) s’appliqueront sur l’incrément de déplacement à partir de l’instant donné sous ETAT_INIT/NUME_DIDI (par défaut l’instant de reprise du calcul) et non sur le déplacement total.

Par exemple pour un déplacement imposé (mot clé DDL_IMPO de [AFFE_CHAR_MECA]) la condition sera de la forme \(u-{u}_{0}=d\) où \({u}_{0}\) est le déplacement défini par NUME_DIDI et non \(u=d\) .

L’option Dirichlet différentiel est à la fois disponible pour des chargements mécaniques (CHAR_MECA) et pour des chargements cinématiques (CHAR_CINE).

Contact#

Le mot-clef facteur CONTACT permet d’introduire les conditions de contact/frottement.

Gestion de la verbosité#

Le mot-clef INFO permet d’effectuer dans le fichier message diverses impressions intermédiaires.

D’autres impressions sont faites systématiquement lors du calcul non linéaire, indépendamment de la valeur affectée au mot-clé INFO : ce sont les impressions des résidus et des incréments relatifs de déplacement au cours des itérations de Newton.

Attention, les fichiers de sortie peuvent devenir très importants avec INFO plus grand que 2.

Bibliographie#

[bib1]

Peter R. Brune, Matthew G. Knepley, Barry F. Smith, and Xuemin Tu. Composing scalable nonlinear algebraic solvers. SIAM Review, 57(4):535–565, 2015. http://www.mcs.anl.gov/papers/P2010-0112.pdf

[bib2]

Dolean and M. J. Gander and F. Kwok and R. Masson and W. Kheriji, Nonlinear Preconditioning: How to use a Nonlinear Schwarz Method to Precondition Newton’s Method, SIAM Journal on Scientific Computing, 38(6), 2016 https://arxiv.org/abs/1605.04419

u4.51.04 Opérateur MECA_NON_LINE#

Contenu de la structure de données EVOL_NOLI#

Paramètres généraux#

Paramétrisation du calcul#

Définition générale de la liste d’instants#

Gestion des reprises#

Sélection des instants#

Réglages des solveurs non-linéaires#

Choix de la méthode#

Méthode de Newton et ses variantes#

Méthode SNES#

Méthode RASPEN#

Recherche linéaire#

Réglages de la convergence#

Critères de convergence avancés#

Réglages du solveur linéaire#

Comportements non-linéaires#

Reprises, archivage et gestion de l’état initial#

Définition d’un état initial#

Archivage des résultats#

Chargements#

Principes généraux#

Chargements incrémentaux#

Contact#

Gestion de la verbosité#

Bibliographie#

Méthode `SNES`#

Méthode `RASPEN`#