u4.51.03 Opérateur STAT_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 à la documentation de référence [Algorithme non linéaire quasi-statique]
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.
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-clé 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.
Selon certaines options de calcul, d’autres champs seront présents:
CONT_NOEU: champ (aux nœuds) des informations sur le contact-frottement (voir [U4.44.11] pour plus de détails sur le contenu de ce champ);
CONT_ELEM: champ (aux éléments) des informations sur le contact-frottement pour la méthode LAC (voir [U4.44.11] pour plus de détails sur le contenu de ce champ);
STRX_ELGA: champ (aux points de Gauss) relatif aux éléments de structure;
HHO_CELL et HHO_FACE: champs spécifiques à la méthode HHO (voir r3.06.14).
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 |
PARM_THETA |
PARM_THETA |
Paramètre d’intégration de la loi de comportement |
R |
ITER_GLOB |
Nombre total d’itérations de Newton |
I |
|
CHAR_MINI |
Chargement minimum atteint au cours du pas de temps |
R |
|
ETA_PILOTAGE |
Paramètre de pilotage |
R |
Quand on recherche des modes d’instabilité (avec STAT_NON_LINE ou DYNA_NON_LINE) ou des modes vibratoires (avec DYNA_NON_LINE seulement), on stocke le champ de déplacement correspondant et la valeur du chargement critique ou la fréquence.
Nom |
Mot-clef origine |
Description |
Type |
CHAR_CRIT |
CRIT_STABavec TYPE = “FLAMBEMENT” |
Chargement critique du mode de flambement |
R |
MODE_FLAMB |
CRIT_STABavec TYPE = “FLAMBEMENT” |
Mode de flambement |
Champ de type DEPL |
CHAR_STAB |
CRIT_STABavec TYPE = “STABILITE” |
Valeur d’instabilité |
R |
MODE_STAB |
CRIT_STABavec TYPE = “STABILITE” |
Mode d’instabilité |
Champ de type DEPL |
FREQ |
MODE_VIBR |
Fréquence du mode vibratoire (juste disponible dans DYNA_NON_LINE) |
R |
DEPL_VIBR |
MODE_VIBR |
Mode vibratoire (juste disponible dans DYNA_NON_LINE) |
Champ de type DEPL |
Nom |
Mot-clef origine |
Description |
Type |
CHAR_CRIT |
CRIT_STAB avec TYPE = “FLAMBEMENT” |
Chargement critique du mode de flambement |
R |
MODE_FLAMB |
CRIT_STAB avec TYPE = “FLAMBEMENT” |
Mode de flambement |
Champ de type DEPL |
CHAR_STAB |
CRIT_STAB avec TYPE = “STABILITE” |
Valeur d’instabilité |
R |
MODE_STAB |
CRIT_STAB avec TYPE = “STABILITE” |
Mode d’instabilité |
Champ de type DEPL |
FREQ |
MODE_VIBR |
Fréquence du mode vibratoire (juste disponible dans DYNA_NON_LINE) |
R |
DEPL_VIBR |
MODE_VIBR |
Mode vibratoire (juste disponible dans DYNA_NON_LINE) |
Champ de type DEPL |
Paramètres généraux#
◆ MODELE = modele,
◆ CHAM_MATER = cham_mater,
◇ CARA_ELEM = cara_elem,
◇ INFO = / 1,
/ 2,
# Si: equal_to("INFO", 2)
◇ INFO_DBG = / "APPARIEMENT",
/ "CONTACT",
/ "FACTOR",
/ "MECANONLINE",
/ "PILOTAGE",
/ "SOLVEUR",
◇ TITRE = text,
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.
Titre#
Le mot-clef TITRE permet de donner un titre au calcul. Il sera imprimé en tête des résultats. Voir [ref:U4.03.01 <U4.03.01>].
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.
Le mot-clef INFO_DBG permet de limiter la sortie à certaines fonctionnalités pour contrôler la taille du fichier de sortie.
Paramétrisation du calcul#
◆ INCREMENT = _F(
# Si: exists("INST_INIT") or exists("INST_FIN")
◇ CRITERE = "RELATIF",
# Si: (equal_to("CRITERE", 'RELATIF'))
◇ PRECISION = float (défaut: 1e-06),
◆ LIST_INST = list_inst / listr8,
◇ / NUME_INST_INIT = int,
/ INST_INIT = float,
◇ / NUME_INST_FIN = int,
/ INST_FIN = float,
),
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 [DEFI_LIST_INST] 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é.
Si INST_INIT n’existe pas dans la liste des instants, on prend le pas de temps immédiatement supérieur
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#
◇ METHODE = / "IMPLEX",
/ "MODELE_REDUIT",
/ "NEWTON" (par défaut),
/ "NEWTON_KRYLOV",
Il existe plusieurs catégories de solveurs non-linéaires accessibles: la méthode de Newton (et ses variantes), la méthode de Newton-Krylov, la méthode IMPLEX, l’accès au solveur non-linéaire SNES de la librairie PETSc et l’utilisation de méthodes de réduction de modèle (ROM). Le solveur est sélectionné par le mot-clef METHODE.
Méthode de Newton#
⟐ NEWTON = _F(
◇ REAC_INCR = int (défaut: 1),
◇ PREDICTION = / "DEPL_CALCULE",
/ "ELASTIQUE",
/ "EXTRAPOLE",
/ "TANGENTE",
◇ MATRICE = / "ELASTIQUE",
/ "TANGENTE" (par défaut),
◇ PAS_MINI_ELAS = float,
◇ REAC_ITER = int (défaut: 1),
◇ REAC_ITER_ELAS = int (défaut: 0),
◇ EVOL_NOLI = evol_noli,
◇ MATR_RIGI_SYME = / "NON" (par défaut),
/ "OUI",
),
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. Le mot-clef MATR_RIGI_SYME sert à forcer la symétrie de la matrice de rigidité. Il est utile lorsqu’on utilise simultanément une fonctionnalité utilisant une matrice non-symétrique (formalisme de Simo-Miehe, chargements de type pression suiveuse, etc) et la formulation de contact de type DISCRETE ou LIAISON_UNIL (cf. [U4.44.11]). En effet, ces dernières ne peuvent fonctionner qu’avec une matrice de rigidité symétrique. Le fait de rendre la matrice de rigidité symétrique a des conséquences sur la vitesse de convergence, pouvant aller jusqu’à son échec mais ne produira jamais de résultats faux. Si le fait de symétriser la matrice de rigidité rend impossible la convergence de l’algorithme de Newton, l’utilisateur est invité à utiliser une formulation de contact de type CONTINUE, qui fonctionne avec une matrice de rigidité non-symétrique.
Phase de prédiction#
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”.
Il est également possible de faire une prédiction en utilisant des résultats préliminaires issus d’un autre calcul.
Pour PREDICTION=”EXTRAPOLE”, on calcule l’estimation de l’incrément de déplacement à partir de l’incrément total obtenu comme solution au pas de temps précédent (pondéré par le rapport des pas de temps). On projette cette estimation sur l’ensemble des champs cinématiquement admissibles (i.e. satisfaisant les conditions aux limites de Dirichlet) selon la norme donnée par la matrice élastique, qui doit donc être calculée. Cette fonctionnalité est intéressante dans le cas de l’utilisation de schémas d’intégration locale explicite de type Runge-Kutta qui ne fournissent pas de matrice tangente: dans ce cas la méthode de Newton utilise une matrice élastique, mais le nombre d’itérations nécessaires peut être élevé. L’utilisation de l’extrapolation peut améliorer les performances.
Pour PREDICTION=”DEPL_CALCULE” propose comme déplacement pour la prédiction à chaque pas de temps, le déplacement donné par une histoire mécanique précisée sous le mot clé EVOL_NOLI (par le mot-clef EVOL_NOLI). Le déplacement est projeté sur l’ensemble des champs cinématiquement admissible, comme pour la méthode EXTRAPOLE.
- Remarques:
Les méthodes “EXTRAPOLE” et “DEPL_CALCULE” procèdent à une projection de la solution sur l’ensemble des champs cinématiquement admissibles. On se sert pour cela des conditions aux limites de Dirichlet donné dans le mot-clef EXCIT. Dans ce cas, il n’est pas possible d’utiliser des chargements de Dirichlet de type «cinématique» (opérande AFFE_CHAR_CINE) mais uniquement des chargements de Dirichlet par dualisation (opérande AFFE_CHAR_MECA). Le calcul fonctionne mais le risque dans ce cas étant que le champ de déplacement ne soit pas cinématiquement admissible, l’utilisateur doit y être attentif.
Les méthodes “EXTRAPOLE’et “DEPL_CALCULE’ne prennent pas en compte les termes de contact à la phase de prédiction. Par conséquent, il est conseillé de choisir les méthodes “ELASTIQUE” ou “TANGENTE” en prédiction pour des calculs de contact.
Il est nécessaire que les déplacements utilisés dans “EXTRAPOLE’et “DEPL_CALCULE” soient issus de calcul utilisant le même maillage car les conditions limites doivent être cohérentes.
Du fait de cette projection sur les conditions limites, ces deux options sont incompatibles avec les fonctionnalités du PILOTAGE.
Ces deux méthodes ont d’autres utilités. Par exemple, si on a obtenu une première solution sur le même maillage avec d’autres paramètres matériaux ou un autre comportement, les champs de déplacements peuvent être réutilisés dans le calcul.
De même, cela permet de réduire la place mémoire et de conserver ces résultats en vue d’une poursuite ultérieure. Pour un gros calcul, on peut stocker uniquement les déplacements à tous les instants dans IMPR_RESU. Si on veut recalculer les contraintes et variables internes, on fait un LIRE_RESU au format adéquat puis on utilise DEPL_CALCULE avec ITER_GLOB_MAXI=0 (on effectue une seule itération) et ARRET=”NON” (il n’y a pas convergence, on ne vérifie pas l’équilibre). Il est toutefois nécessaire pour des raisons de syntaxe de donner un chargement (éviter les chargements Dirichlet qui imposent une résolution linéaire) ainsi qu’un critère de convergence, même si ces informations ne sont pas prises en compte.
Avertissement
Du fait de l’impossibilité de «projeter» correctement les conditions limites d’un maillage à l’autre, il est désormais fortement déconseillé d’utiliser EXTRAPOLE et DEPL_CALCULE à partir d’un maillage différent du calcul courant.
Phase de correction#
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_INCR 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 [DEFI_MATERIAU], 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)
Le mot-clef REAC_ITER 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.
Bascule de la matrice en correction#
Les options PAS_MINI_ELAS et REAC_ITER_ELAS permettent de passer de la matrice tangente à la matrice de décharge (i.e en considérant que les non-linéarités n’évoluent pas) lorsque le pas de temps est inférieur à PAS_MINI_ELAS. Cette matrice de décharge est la matrice élastique pour les modèles de comportement de type plastique; pour les modèles d’endommagement elle s’identifie à la matrice sécante.
Comme la convergence avec la matrice élastique est plus lente que celle avec la matrice tangente, le mot clé ITER_GLOB_ELAS sous le mot clé facteur CONVERGENCE permet de définir un nombre d’itérations maximal spécifique à l’utilisation de la matrice élastique et différent de celui associé à l’utilisation de la matrice tangente.
On peut définir une fréquence de réactualisation de la matrice de décharge avec le mot-clé REAC_ITER_ELAS (analogue de REAC_ITER). Si la matrice de décharge ne dépend pas de l’état de déformation (ce qui est le cas pour les matériaux plastiques mais pas pour les modèles d’endommagement), prendre REAC_ITER_ELAS = 0 (puisqu’elle sera la même au cours des itérations).
Ces options peut être utile lorsque le redécoupage automatique du pas de temps ne suffit pas à faire converger un calcul. Par exemple, dans le cas de lois adoucissantes, la matrice tangente peut devenir singulière et il vaut donc mieux utiliser la matrice élastique pour converger.
Méthode de Newton-Krylov#
Si on choisit METHODE=”NEWTON_KRYLOV”, on utilise une version inexacte de l’algorithme de Newton-Raphson; la précision des résolutions des systèmes linéaires par une méthode itérative est adaptée au cours de chaque pas de chargement (voir [R5.03.01]). Toutes les options décrites pour la méthode de Newton (gestion des matrices, de la réactualisation, etc.) sont utilisables par la méthode de Newton-Krylov.
Méthode IMPLEX#
Quand METHODE=”IMPLEX”, on utilise l’algorithme IMPLEX pour résoudre le problème (voir [ref:R5.03.81 <R5.03.81>]). Cette méthode n’est utilisable qu’avec un nombre limité de : comportements.
Méthode de réduction de modèle (ROM)#
◆ MODELE_REDUIT = _F(
◇ REAC_INCR = int (défaut: 1),
◇ PREDICTION = / "DEPL_CALCULE",
/ "ELASTIQUE",
/ "EXTRAPOLE",
/ "TANGENTE" (par défaut),
◇ MATRICE = / "ELASTIQUE",
/ "TANGENTE" (par défaut),
◇ REAC_ITER = int (défaut: 1),
◆ BASE_PRIMAL = mode_empi,
◇ DOMAINE_REDUIT = / "NON" (par défaut),
/ "OUI",
◇ EVOL_NOLI = evol_noli,
# Si: (equal_to("DOMAINE_REDUIT", 'OUI'))
◆ GROUP_NO_INTERF = grno,
◇ CORR_COMPLET = / "NON" (par défaut),
/ "OUI",
# Si: (equal_to("CORR_COMPLET", 'OUI'))
◇ COEF_PENA = float (défaut: 1000000.0),
◆ GROUP_NO_ENCASTRE = grno,
),
Quand METHODE=”MODELE_REDUIT”, on utilise une méthode de réduction de modèle pour faire le calcul non-linéaire (voir [R5.01.05]). Il est nécessaire d’avoir construit une base réduite préalablement (commande [DEFI_BASE_REDUITE]).
- La réduction de modèle n’est pas compatible avec les fonctionnalités suivantes:
le contact et le frottement (toutes méthodes)
le pilotage,
la recherche linéaire,
les conditions limites dualisées (AFFE_CHAR_MECA): il faut utiliser AFFE_CHAR_CINE,
les modèles mixtes: la réduction de modèle est uniquement compatible avec des éléments finis en déplacement (pas de modèles de structure non plus)
On peut préciser les caractéristiques de la méthode de résolution du problème incrémental non-linéaire par une méthode de réduction de modèle. La stratégie de prédiction peut être réglée comme dans le cas de Newton avec le mot-clef PREDICTION. On peut régler la réactualisation des matrices avec les mots-clefs REAC_INCR et REAC_ITER.
La base réduite est donnée par le mot-clef BASE_PRIMAL. Cette base doit avoir été construite sur le même modèle et le même maillage que le calcul (mais les chargements, les matériaux et le comportement peuvent être différents).
Il est possible d’activer l’hyper-réduction qui utilise une méthode de type dEIM (discrete Empirical Interpolation Method) par DOMAINE_REDUIT=”OUI”. Dans ce cas, le calcul est réduit sur une zone du maillage restreinte (appelée RID) et construite à l’aide de l’opérateur [DEFI_DOMAINE_REDUIT].
Il faut donner le groupe de noeuds sur lequel est défini l’interface entre le RID et le reste du domaine à l’aide du mot-clef GROUP_NO_INTERF.
Pour améliorer la qualité des résultats en hyper-réduction, il est possible de faire une correction du calcul hyper-réduit par un calcul élément fini détaillé avec CORR_COMPLET=”OUI”. Pour cela, il est nécessaire de définir un groupe de noeuds servant à faire la liaison entre le RID et le reste du modèle avec le mot-clef GROUP_NO_ENCASTRE (défini par exemple dans la commande [DEFI_DOMAINE_REDUIT]). Ce groupe de noeuds permet d’imposer les conditions limites de Dirichlet nécessaire à ce que le problème corrigé soit bien défini. Ces conditions limites étant définies par pénalisation, le coefficient de pénalisation peut être changé par le mot-clef COEF_PENA.
Cette correction se faisant toujours sur le domaine réduit, elle ne sera pas aussi précise qu’un vrai calcul détaillé (domaine complet). Néanmoins, elle est très utile lorsque l’on change de manière significative les conditions limites entre la définition de la base réduite (phase off-line dans [DEFI_BASE_REDUITE]) et le calcul utilisant cette base réduite (phase on-line dans STAT_NON_LINE).
Recherche linéaire#
◇ RECH_LINEAIRE = _F(
◇ METHODE = / "CORDE" (par défaut),
/ "MIXTE",
/ "PILOTAGE",
◇ RESI_LINE_RELA = float (défaut: 0.1),
◇ ITER_LINE_MAXI = int (défaut: 3),
◇ RHO_MIN = float (défaut: 0.01),
◇ RHO_MAX = float (défaut: 10.0),
◇ RHO_EXCL = float (défaut: 0.009),
),
La recherche linéaire peut permettre d’améliorer la convergence de la méthode de Newton (Cf.:ref:R5.03.01<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 facteur RECH_LINEAIRE permet d’activer la recherche linéaire (voir [R5.03.01]).
La mot-clef METHODE permet de choisir la méthode de recherche linéaire, c’est-à-dire l’algorithme de recherche du zéro de la fonctionnelle. La méthode CORDE (par défaut) est la méthode la plus simple, c’est une méthode sécante unidimensionnelle.
La méthode MIXTE est plus élaborée et utilise une méthode sécante avec des bornes variables. Elle est plus efficace lorsque la fonctionnelle n’est pas strictement concave (problèmes avec endommagement ou THM par exemple).
La méthode PILOTAGE est réservée au pilotage de type DEFORMATION, PRED_ELAS et LONG_ARC (voir le paragraphe sur le pilotage ). C’est la seule méthode utilisable avec ce type de pilotage. Pour le pilotage de type DDL_IMPO, on peut utiliser CORDE ou MIXTE.
On donne le nombre d’itérations maximum à effectuer par ITER_LINE_MAXI et la précision à atteindre par RESI_LINE_RELA pour réaliser la convergence de la recherche linéaire.
Pour la méthode CORDE, Il n’est pas nécessaire de spécifier une précision ni un nombre d’itérations très élevés, la pratique montrant que deux ou trois itérations de recherche linéaire sont suffisantes. On peut donc se contenter de demander trois itérations avec la précision par défaut. L’utilisateur ne peut pas mettre plus de 999 itérations de recherche linéaire pour la méthode CORDE.
Par contre, pour la méthode MIXTE, sur des problèmes avec endommagement, plusieurs dizaines d’itérations sont souvent efficaces.
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
Contrôle de la THM#
◇ SCHEMA_THM = _F(
◇ PARM_THETA = float (défaut: 1.0),
◇ PARM_ALPHA = float (défaut: 1.0),
),
Le mot-clef SCHEMA_THM permet de gérer les paramètres des schémas THM pour l’hydraulique (PARM_THETA, voir [R7.01.10]) et pour les volumes finis de type SUSHI (PARM_ALPHA, voir [R7.01.34]).
Ce paramètre PARM_THETA est bien distinct de celui défini dans le mot-clé COMPORTEMENT.
Chargements#
◇ EXCIT = _F(
◆ CHARGE = char_cine_meca / char_meca,
◇ FONC_MULT = fonction / formule / nappe,
◇ TYPE_CHARGE = / "DIDI",
/ "FIXE_CSTE" (par défaut),
/ "FIXE_PILO",
/ "SUIV",
/ "SUIV_PILO",
),
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 .
La partie spatiale du chargement \(\underline{L}_{ext} \left ( \underline{u} \right )\) est donnée par le mot-clé 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 [AFFE_MATERIAU]), 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 calcul, 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-clé 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-clé 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 suiveurs#
Si TYPE_CHARGE=”SUIV”, le chargement est dit «suiveur», c’est-à-dire qu’il dépend de la valeur des inconnues: par exemple, la pression, étant un chargement s’appliquant dans la direction normale à une structure, dépend de la géométrie actualisée de celle-ci, et donc des déplacements. Un chargement suiveur est réévalué à chaque itération de l’algorithme de résolution.
Actuellement les chargements qui peuvent être qualifiés de suiveur sont le chargement de pesanteur pour l’élément de CABLE_POULIE, la pression pour les modélisations 3D, 3D_SI, D_PLAN, D_PLAN_SI, AXIS, AXIS_SI, C_PLAN, C_PLAN_SI, COQUE_3D et pour toutes les modélisations THM et la force centrifuge en grands déplacements (mot clé ROTATION dans [AFFE_CHAR_MECA]). Il y a également la force surfacique FORCE_FACE pour les éléments 3D. On peut également imposer qu’un chargement de Dirichlet soit suiveur dans le cas de la rigidification d’une partie de la structure par l’utilisation de LIAISON_SOLIDE ( voir [AFFE_CHAR_MECA]) en grandes transformations.
- Remarques:
La pression peut être définie par une fonction dépendant de la géométrie. Dans le cas suiveur, on peut choisir si cette dépendance se fait par rapport à la géométrie initiale avec les paramètres X, Y et Z de [DEFI_FONCTION] ou par rapport à la géométrie réactualisée avec les paramètres XF, YF et ZF.
Le chargement de type LIAISON_SOLIDE suiveur est strictement incompatible avec le pilotage et la recherche linéaire. Il n’est utilisable qu’avec des éléments finis isoparamétriques 2D et 3D (pas avec les éléments de structures tels que poutre, plaques et coques).
Dans le cas des COQUE_3D, le chargement de pression peut-être créé par les mots-clés PRES_REP/PRES ou FORCE_COQUE/PRES d’[AFFE_CHAR_MECA]. Les autres opérandes de FORCE_COQUE (FX, FY…, F1, F2, …) ne sont pas compatibles avec les chargements suiveurs.
Chargements pilotés#
Si TYPE_CHARGE vaut “FIXE_PILO”, le chargement est toujours fixe (indépendant de la géométrie) mais il sera piloté grâce au mot-clé facteur PILOTAGE. Les charges pilotables doivent être issues de l’opérateur [AFFE_CHAR_MECA] ou [AFFE_CHAR_MECA_F] (si ce n’est pas une fonction dépendant du temps) et ne doivent pas être affectées du mot clé FONC_MULT.
On ne peut pas piloter les chargements de pesanteur, la force centrifuge, les forces de Laplace, les chargements thermiques ou de déformations initiales ou anélastiques, et les conditions de liaison.
Pour avoir des charges pilotées dépendantes de la géométrie (charges dites «suiveuses»), on utilise TYPE_CHARGE=”SUIV_PILO”.
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).
Pilotage#
Le pilotage est parfois connu sous la dénomination de méthode de continuation.
◇ PILOTAGE = _F(
◆ TYPE = / "ANA_LIM",
/ "DDL_IMPO",
/ "DEFORMATION",
/ "LONG_ARC",
/ "PRED_ELAS",
◇ COEF_MULT = float (défaut: 1.0),
◇ EVOL_PARA = / "CROISSANT",
/ "DECROISSANT",
/ "SANS" (par défaut),
◇ ETA_PILO_MAX = float,
◇ ETA_PILO_MIN = float,
◇ ETA_PILO_R_MAX = float,
◇ ETA_PILO_R_MIN = float,
◇ PROJ_BORNES = / "NON",
/ "OUI" (par défaut),
# Si: equal_to("TYPE", 'LONG_ARC') or equal_to("TYPE", )
◇ SELECTION = / "ANGL_INCR_DEPL",
/ "MIXTE",
/ "NORM_INCR_DEPL" (par défaut),
/ "RESIDU",
# Si: not equal_to("TYPE", 'LONG_ARC')
◇ SELECTION = / "MIXTE",
/ "NORM_INCR_DEPL" (par défaut),
/ "RESIDU",
◇ / TOUT = "OUI" (ou non renseigné),
/ GROUP_MA = list[grma],
◇ / NOEUD = list[no],
/ GROUP_NO = list[grno],
◇ NOM_CMP = list[text],
),
Principes généraux#
Lorsque l’intensité \(\eta\) d’une partie du chargement n’est pas connue a priori (chargement dit de référence défini dans [AFFE_CHAR_MECA] avec charge de type FIXE_PILO), le mot clé PILOTAGE permet de piloter ce chargement par l’intermédiaire d’un nœud (ou groupe de nœuds) sur lequel on peut imposer différents modes de pilotage (mot clé TYPE).
- Remarques:
Avec FIXE_PILO, on ne peut pas utiliser pour le chargement de référence le mot clé FONC_MULT.
Lorsque le chargement de référence est défini par [AFFE_CHAR_MECA_F], ce chargement peut être fonction des variables d’espace mais pas du temps. De même, les changements issus de variables de commande (comme la température) qui dépendent du temps ne sont pas utilisables avec le pilotage.
Le pilotage est interdit avec le contact.
Il n’est pas possible de faire du pilotage avec PREDICTION=”DEPL_CALCULE” ou PREDICTION=”EXTRAPOLE”
Les types de pilotage#
Le type de pilotage effectué est donné par le mot-clé TYPE. Sept modes de pilotage sont disponibles (Confer [R5.03.80] pour plus de détails).
Pilotage pour les déplacements#
Le pilotage pour les déplacements va contrôler l’intensité du chargement pour contrôler un déplacement ou équivalent.
Le TYPE=”DDL_IMPO” permet d’imposer une valeur donnée d’incrément de déplacement (une seule composante \(i\) possible) en un unique nœud (ou d’un groupe de nœuds ne comportant qu’un seul nœud) donnés par les mots-clés NOEUD ou GROUP_NO. À chaque incrément de temps, on cherche l’amplitude \(\eta\) du chargement de référence qui permettra de satisfaire la relation incrémentale suivante
Le TYPE=”LONG_ARC” permet de piloter l’intensité \(\eta\) du chargement de référence par la longueur (abscisse curviligne) de la réponse en déplacement d’un groupe de nœuds (à utiliser par exemple lorsqu’on veut contrôler le flambement d’une éprouvette). On vérifie la relation suivante:
avec \(\parallel (\Delta u)\parallel =(\sqrt{\sum_{n}\sum_{c}({\Delta u}_{n,c}^{2})})\)
où \(n\) sont les nœuds du pilotage et \(c\) les composantes du déplacement des nœuds considérés. Même si le groupe de nœuds du pilotage est réduit à un seul nœud, il faut quand même utiliser GROUP_NO.
Pour les deux types, \(C\) est donné par le mot-clé COEF_MULT et NOM_CMP donne le nom de la composante (correspondant au degré de liberté \(i\) ) utilisée pour le pilotage (“DX” par exemple).
Pilotage pour l’analyse limite#
Le pilotage TYPE=”ANA_LIM” est spécifique au calcul de charge limite (loi NORTON_HOFF) par approche cinématique ( cf. [ref:R7.07.01 <R7.07.01>] pour plus de détails). Si \(F\) désigne le chargement assemblé piloté (indiqué par TYPE_CHARGE=”FIXE_PILO”), alors la fonction de pilotage s’écrit simplement:
Excepté pour le calcul de charge limite, cette fonctionnalité ne présente pas d’intérêt a priori. Pour ce mode de pilotage, aucun autre mot clé n’est à préciser.
Pilotage pour les comportements adoucissants#
L’utilisation de lois de comportement adoucissantes peut conduire à des snap-backs brutaux qui rendent délicat le déroulement du calcul. Les deux modes de pilotage suivants y remédient : (Cf. [R5.03.80] pour plus de détails).
Le pilotage TYPE=”DEFORMATION” garantit qu’au moins un point de Gauss de la structure voit sa déformation évoluer de façon monotone. On vérifie la relation:
Ce mode de pilotage est valable pour toutes les lois de comportement y compris en grandes déformations SIMO_MIEHE.
Lorsqu’on veut utiliser ce mode de pilotage, il est indispensable de faire un premier calcul sans le mot clé PILOTAGE pour amorcer le problème et obtenir un état initial \({\varepsilon}^{-}\) différent de zéro (sinon division par zéro). On effectue après une reprise à partir de cet état initial non nul et on utilise le pilotage.
Le pilotage TYPE=”PRED_ELAS” assure qu’au moins un point de Gauss de la structure sorte du seuil d’élasticité linéarisé \({f}_{\text{pred-elas}}\) d’une quantité \(\frac{\Delta t}{C}\) .
On vérifie la relation:
Ce mode de pilotage est valable uniquement pour les lois ENDO_SCALAIRE (avec la version non locale), VMIS_ISOT_NL (avec la version locale uniquement), ENDO_FISS_EXP (non locale uniquement), ENDO_ISOT_BETON et ENDO_ORTH_BETON (avec la version locale et la version non locale), BARENBLATT, BETON_DOUBLE_DP, CZM_EXP (avec les éléments à discontinuité interne *_ELDI) , CZM_OUV_MIX, CZM_TAC_MIX et CZM_LAB_MIX (éléments d’interface *_INTERFACE), CZM_EXP_REG (éléments de joint *_JOINT ou modélisation X-FEM) et CZM_LIN_REG (éléments de joint).
\(C\) est donné par le mot-clé COEF_MULT mais la fixation de ce paramètre est difficile à définir du premier coup parce que la notion de sortie de critère \(\frac{\Delta t}{C}\) n’est pas intuitive et varie selon les lois de comportement. Pour les lois ENDO_SCALAIRE, ENDO_FISS_EXP et ENDO_ISOT_BETON, une version différente de la définition de \(\frac{\Delta t}{C}\) est utilisée, où ce paramètre est lié à l’incrément d’endommagement (voir [R7.01.04]).
La résolution des deux équations précédentes permet d’obtenir l’intensité du chargement inconnue. Dans certains cas, la résolution de ces équations peut conduire à plusieurs solutions pour l’intensité. On choisit alors toujours la solution qui est la plus proche de \({\varepsilon}^{-}\) . C’est pourquoi, lorsqu’on veut imposer un chargement alterné, on est obligé à chaque changement de signe du chargement de réaliser un premier calcul sans le mot clé PILOTAGE afin d’obtenir un état initial \({\varepsilon}^{-}\) de traction ou de compression. On effectue ensuite un second calcul en poursuite à partir de l’état initial précédent avec le mot clé PILOTAGE.
Ces deux types de pilotage ne sont pas disponibles pour les éléments de structures.
On donne les mailles ou groupes de mailles servant à piloter le calcul par les mots-clés GROUP_MA, MAILLE ou TOUT. Intéressant pour alléger la résolution des équations de ces modes de pilotage.
Contrôle des bornes#
Ces mots-clés ETA_PILO_R_MAX et ETA_PILO_R_MIN permettent de définir l’intervalle de recherche des valeurs de pilotage. À chaque itération de Newton toutes les valeurs de pilotage en dehors de \([\eta^{R}_{min}, \eta^{R}_{max}]\) sont ignorées. Ceci peut conduire à «échec de pilotage» si cet intervalle est trop restrictif.
Si on ne précise pas de valeurs, c’est \(\eta^{R}_{min}=-\infty\) et \(\eta^{R}_{max}=+\infty\).
Une utilisation possible de cet intervalle est la suivante. On désire, par exemple, piloter une pression imposée à la structure et on s’attend à garder cette pression positive. En fixant \(\eta^{R}_{min}=-0\), cela permet d’imposer les valeurs de pilotage positives.
Les mots-clés ETA_PILO_MAX et ETA_PILO_MIN permettent de préciser l’intervalle de valeurs de pilotage souhaité. On l’utilise pour arrêter proprement le calcul lorsque ETA_PILOTAGE atteint les bornes de cet intervalle.
Cet intervalle doit être plus restrictif que l’intervalle de recherche défini précédemment, car ce dernier est appliqué dans tous les cas. Le principe de fonctionnement est le suivant : à convergence des itérations de Newton, si l’on a atteint l’une des bornes, le calcul s’arrête.
Une utilisation possible de cet intervalle est la suivante. Dans le cas de présence de snap-back, en fixant \(\eta_{min}\) à une faible valeur, cela permet d’arrêter le calcul avant une déchirure/endommagement complet de l’échantillon et éviter ainsi la divergence au dernier pas de temps.
L’autre utilisation possible est celle de \(\eta_{max}\) en tant que charge limite maximale.
Avec la loi ENDO_ISOT_BETON, ces deux mots clés sont obligatoires, car ils sont utilisés pour fixer les bornes de pilotage au niveau élémentaire.
En cas de dépassement de l’intervalle \([\eta_{min}, \eta_{max}]\), l’utilisateur peut indiquer s’il veut projeter la valeur de pilotage sur \([\eta_{min}, \eta_{max}]\) avec PROJ_BORNES=”OUI”.
Avec PROJ_BORNE=”OUI”, la projection sera effectuée (si \(\eta>\eta_{max}\) alors \(\eta=\eta_{max}\); si \(\etaw\eta_{min}\) alors \(\eta=\eta_{min}\)), ce qui permet, en cas de convergence d’arrêter le calcul précisément sur \(\eta_{min}\) ou \(\eta_{max}\).
Avec PROJ_BORNE=”NON”, on ne modifie pas les valeurs de eta, même si pendant les itérations de Newton cette dernière a une valeur supérieure à \(\eta_{max}\) ou inférieure à \(\eta_{min}\). Par contre le calcul est arrêté, si à la convergence \(\eta\) dépasse les bornes.
Une utilisation possible de l’intervalle \([\eta_{min}, \eta_{max}]\) avec l’option PROJ_BORNE=”OUI” est le suivant. On désire, par exemple, comparer plusieurs calculs pour un modèle adoucissant, qui sont pilotés en déplacement. Ces paramètres de pilotage permettent de stopper les calculs au même chargement lorsque la structure est suffisamment adoucie. Cette stratégie rend la comparaison plus aisée, grâce au contrôle du dernier point de pilotage.
Il est vivement conseillé de faire appel à l’option PROJ_BORNE=”OUI” lors de la mise en place de cas test impliquant du pilotage du chargement. Cela permet en effet d’arrêter le calcul en des points précis où l’on vient tester les valeurs, ce qui améliore la robustesse du test et facilite sa maintenance. Un exemple de cette mise en donnée est proposé dans les tests ssnp133a et ssnp133d.
Avec PROJ_BORNE=”NON” on peut dans certains cas à débloquer les calculs, qui autrement ne convergent pas avec les conditions trop restrictives imposées via l’intervalle \([\eta^{R}_{min}, \eta^{R}_{max}]\). Soit on pilote une pression imposée à la structure et on s’attend à garder cette pression positive. En fixant \(\eta^{R}_{min}=0\), le calcul s’arrête en échec de pilotage. En revanche en imposant \(\eta^{R}_{min}\) légèrement négatif, on autorise de facto le passage par un état «non physique» pendant les itérations de Newton, ce qui facilite la convergence. L’état convergé dans ce cas peut aussi bien être physique (pression positive) ou non physique. C’est la valeur de \(\eta^{R}_{min}=0\), qui gouvernera le comportement en cas de convergence hors bornes. Cette stratégie permet de ne conserver que les valeurs de pilotage positives, si on trouve au moins une valeur de pilotage positive.
Contrôle des solutions multiples#
Le mot-clé SELECTION permet de sélectionner la méthode permettant de choisir la valeur de pilotage dans le cas où plusieurs solutions sont fournies par la résolution de pilotage.
SELECTION=”NORM_INCR_DEPL” permet de sélectionner la valeur de pilotage par la plus petite norme de l’incrément de déplacement sur le pas de temps considéré.
SELECTION=”ANGL_INCR_DEPL” permet de sélectionner la valeur de pilotage par le plus petit angle entre le déplacement obtenu pour le pas de temps courant et le déplacement obtenu pour le pas de temps précédent. Ce choix est disponible uniquement avec TYPE=LONG_ARC.
SELECTION=”RESIDU” permet de sélectionner la valeur de pilotage conduisant au plus petit résidu.
SELECTION=”MIXTE” permet de sélectionner la valeur de pilotage en s’appuyant sur plusieurs stratégies. On commence avec la stratégie NORM_INCR_DEPL ci-dessus. Si les résultats de la fonction objectif (la norme de l’incrément de déplacement) sont trop proches, on bascule pour cette itération sur la stratégie RESIDU. Là encore, si les résidus sont trop proches, on revient à la stratégie NORM_INCR_DEPL et on examine si la liste des résidus RESI_GLOB_MAXI du pas de temps courant présente des cycles. Si c’est le cas, c’est la moins bonne solution de NORM_INCR_DEPL qui est choisie pour cette itération. Sinon, on choisit simplement la meilleure des deux, même si elles ne sont pas suffisamment contrastées.
- Remarque:
Si on fait une reprise de calcul (reuse) avec le mot-clé SELECTION=”ANGL_INCR_DEPL”, il est important de garder à l’esprit que ce critère nécessite les deux pas de temps précédents. Il faudra donc bien prendre soin d’archiver correctement les résultats du précédent calcul au risque d’obtenir des résultats faux. Une alarme avertit l’utilisateur dans cette situation.
Le mot-clé EVOL_PARA permet d’imposer la croissance ou la décroissance du paramètre de pilotage.
Réglages de la convergence#
⟐ CONVERGENCE = _F(
# Si: exists("RESI_REFE_RELA")
◆ | EFFORT_REFE = float,
| SIGM_REFE = float,
| EPSI_REFE = float,
| FLUX_THER_REFE = float,
| MOMENT_REFE = float,
| FLUX_HYD1_REFE = float,
| FLUX_HYD2_REFE = float,
| VARI_REFE = float,
| DEPL_REFE = float,
| LAGR_REFE = float,
| PI_REFE = float,
◆ | RESI_REFE_RELA = float,
| RESI_GLOB_MAXI = float,
| RESI_GLOB_RELA = float,
◇ / RESI_COMP_RELA = float,
◇ ITER_GLOB_MAXI = int (défaut: 10),
◇ ITER_GLOB_ELAS = int (défaut: 25),
◇ ARRET = / "NON",
/ "OUI" (par défaut),
◇ VERIF = / "AU_MOINS_UN",
/ "TOUT" (par défaut),
),
Le mot-clé facteur CONVERGENCE permet de contrôler les paramètres de convergence du calcul.
Quand VERIF= »TOUT », tous les critères de convergence activés (RESI_GLOB_RELA, RESI_GLOB_MAXI, RESI_REFE_RELA et RESI_COMP_RELA) sont vérifiés simultanément, quand VERIF= »AU_MOINS_UN », un seul des critères activés suffit pour établir la convergence
Il convient d’être très prudent dans l’usage de VERIF = « AU_MOINS_UN » car si” l’un des critères est très relâché, cela peut conduire à des résultats faux .
Critères de convergence standards#
Il existe plusieurs critères de convergence: les deux plus courants sont 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=:math:varepsilon_{max}, l’algorithme continue les itérations globales tant que
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=:math:varepsilon_{rel}, l’algorithme continue les itérations globales tant que
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_COMP_RELA=:math:varepsilon_{cmp} conduit à estimer la convergence de l’algorithme de Newton en raisonnant composante par composante. Pour cela, on distingue dans le vecteur résidu les sous-vecteurs correspondant à chaque composante \(\mathrm{cmp}\) (par exemple en THM, \(\mathrm{cmp}=\left\lbrace \mathrm{DX},\mathrm{DY},\mathrm{DZ},\mathrm{PRE1},\mathrm{PRE2},\mathrm{TEMP}\right\rbrace\) ).
On norme ensuite ces sous-vecteurs par la force interne correspondante. Ainsi, l’algorithme continue les itérations globales tant que
où \({F}^{c,n}\) est la partie du résidu \({F}^{n}\) correspondant à la composante \(c\) et \({L}^{int,c,n}\) le vecteur des forces internes au temps \(n\) correspondant à cette même composante \(c\) (Cf. [R5.03.01] pour plus de détails).
Les forces internes au temps \(n\) sont calculées en début de pas de temps à partir du résultat issu du pas de temps précédent. Pour le premier pas de temps, on passe automatiquement à un critère relatif de type RESI_GLOB_RELA, voir à un critère absolu pour les cas où le chargement est nul.
Ce critère n’a d’intérêt que pour des problèmes de type évolutif (THM) où résident de forts contrastes entre les différentes inconnues.
Le critère RESI_REFE_RELA=:math: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:
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.
Gestion des itérations#
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.
Ce test est toujours effectué sauf dans le cas du redécoupage du pas de temps par la méthode “EXTRAPOLE”. Dans le cas de la résolution d’un problème de contact/frottement par la formulation CONTINUE en Newton généralisé, il est souvent nécessaire d’augmenter le nombre d’itérations de Newton au-delà de sa valeur par défaut.
Le mot-clef ITER_GLOB_ELAS fixe le Nombre d’itérations maximum effectué avec la matrice élastique lorsqu’on utilise le mot clé PAS_MINI_ELAS du mot clé facteur NEWTON pour résoudre le problème global à chaque instant. On rappelle que PAS_MINI_ELAS permet de passer de la matrice tangente à la matrice élastique lorsque le pas de temps est ou devient (par le redécoupage) inférieur à une certaine valeur précisée sous PAS_MINI_ELAS.
Contrairement à ITER_GLOB_MAXI, ce paramètre peut facilement prendre des grandes valeurs (plusieurs centaines) car la convergence sur un problème non-linéaire avec la matrice élastique (très raide) est lente bien qu’assurée du point de vue théorique pour toutes les lois décrivant les matériaux standards généralisés.
Gestion de l’arrêt#
Si un des critères de convergence globale choisis n’est pas vérifié après le nombre maximal d’itérations, alors le calcul s’arrête (les résultats précédents sont sauvegardés).
Il est néanmoins possible de continuer le calcul en utilisant ARRET=”NON”.
Avertissement
Cette possibilité est à réserver à des cas très particuliers car elle donne des résultats faux.
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].
Contrôle de la qualité d’un calcul#
◇ CRIT_QUALITE = _F(
◇ ERRE_TEMPS_THM = / "NON" (par défaut),
/ "OUI",
),
Le mot-clef facteur CRIT_QUALITE permet d’activer le calcul des indicateurs d’erreur. ERRE_TEMPS_THM est l’indicateur d’erreur temporel pour les modélisations HM instationnaires, voir [R4.10.05].
Reprises, archivage et gestion de l’état initial#
◇ RESULTAT = evol_noli,
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#
◇ ETAT_INIT = _F(
◆ | DEPL = cham_no,
| EVOL_NOLI = evol_noli,
| SIGM = carte / cham_elem,
| VARI = cham_elem,
◇ STRX = cham_elem,
# Si: exists("EVOL_NOLI")
◇ NUME_ORDRE = int,
◇ NUME_DIDI = int,
◇ INST = float,
# Si: exists("INST")
◇ CRITERE = / "ABSOLU",
/ "RELATIF" (par défaut),
# Si: (equal_to("CRITERE", 'RELATIF'))
◇ PRECISION = float (défaut: 1e-06),
# Si: (equal_to("CRITERE", 'ABSOLU'))
◆ PRECISION = float,
),
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 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.
D’autres champs ne sont disponibles que dans certaines modélisations:
Le mot-clef STRX donne le champ d’efforts et de déplacements correspondant aux éléments de structures
Si un résultat donné par le mot-clef EVOL_NOLI est également donné, les champs ci-dessus viennent le surcharger.
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.
Dans le cas de chargements de type Dirichlet différentiel DIDI, on donne sous NUME_DIDI le numéro d’archivage de l’état mécanique (déplacements) qui sert de référence pour l’application de ces conditions aux limites. Par défaut on prend l’état mécanique défini sous NUME_ORDRE ou INST.
Archivage des champs#
⟐ ARCHIVAGE = _F(
◆ / PAS_ARCH = int,
/ LIST_INST = listr8,
/ INST = float,
# Si: exists("INST") or exists("LIST_INST")
◇ CRITERE = / "ABSOLU",
/ "RELATIF" (par défaut),
# Si: equal_to("CRITERE", 'RELATIF')
◇ PRECISION = float (défaut: 1e-06),
# Si: equal_to("CRITERE", 'ABSOLU')
◆ PRECISION = float,
◇ CHAM_EXCLU = text (défaut: "('RESI_NOEU', 'RESI_RELA_NOEU')"),
),
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 (tous les PAS_ARCH pas 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.
Archivage personnalisé#
◇ OBSERVATION = _F(
◇ TITRE = text,
◇ OBSE_ETAT_INIT = / "NON",
/ "OUI" (par défaut),
◇ EVAL_CHAM = / "MAX",
/ "MAXI_ABS",
/ "MIN",
/ "MINI_ABS",
/ "MOY",
/ "VALE" (par défaut),
◆ / NOM_CMP = text,
/ NOM_VARI = text,
◇ EVAL_CMP = / "FORMULE",
/ "VALE" (par défaut),
◇ INST = float,
◇ LIST_INST = listr8,
◇ PAS_OBSE = int,
◇ CRITERE = / "ABSOLU",
/ "RELATIF" (par défaut),
◆ NOM_CHAM = / "ACCE",
/ "ACCE_ABSOLU",
/ "CONT_ELEM",
/ "CONT_NOEU",
/ "DEPL",
/ "DEPL_ABSOLU",
/ "EPSI_ELGA",
/ "FORC_NODA",
/ "SIEF_ELGA",
/ "VARI_ELGA",
/ "VITE",
/ "VITE_ABSOLU",
# Si: (equal_to("EVAL_CMP", 'FORMULE'))
◆ FORMULE = formule,
# Si: is_in("NOM_CHAM", ('DEPL','VITE','ACCE','TEMP','FORC_NODA','CONT_NOEU','DEPL_ABSOLU','VITE_ABSOLU','ACCE_ABSOLU'))
◆ / TOUT = "OUI" (ou non renseigné),
/ NOEUD = no,
/ GROUP_NO = grno,
/ GROUP_MA = grma,
/ MAILLE = ma,
# Si: is_in("NOM_CHAM", ('SIEF_ELGA','EPSI_ELGA','VARI_ELGA'))
◆ / TOUT = "OUI" (ou non renseigné),
/ GROUP_MA = grma,
/ MAILLE = ma,
◇ EVAL_ELGA = / "MAX",
/ "MIN",
/ "VALE" (par défaut),
# Si: (equal_to("EVAL_ELGA", 'VALE'))
◆ POINT = int,
◇ SOUS_POINT = int,
# Si: (equal_to("NOM_CHAM", 'CONT_ELEM'))
◆ / TOUT = "OUI" (ou non renseigné),
/ GROUP_MA = grma,
/ MAILLE = ma,
# Si: (equal_to("CRITERE", 'RELATIF'))
◇ PRECISION = float (défaut: 1e-06),
# Si: (equal_to("CRITERE", 'ABSOLU'))
◆ PRECISION = float,
),
Le mot-clef facteur OBSERVATION permet de post-traiter certains champs aux nœuds ou aux éléments sur des parties de modèle à des instants d’une liste (dite d’observation) généralement plus raffinée que la liste des instants archivés définie dans le mot clé ARCHIVAGE (où on stocke tous les champs sur tout le modèle). Il sert essentiellement à des économies de stockage, mais aussi à évaluer des champs sur des parties réduites du maillage, sans avoir besoin de post-traiter après le calcul. Il est possible, par exemple, de calculer la norme des contraintes, au sens de von Mises, et de la stocker dans la table d’observation.
Ce mot clé est répétable et permet la création d’une table d’observation de même nom que le concept résultat de STAT_NON_LINE que l’on pourra extraire à l’aide de la commande [RECU_TABLE].
On ne peut utiliser que 99 occurrences du mot-clef OBSERVATION au maximum.
Il est possible de nommer une occurrence de l’observation (colonne NOM_OBSERVATION ) en utilisant le mot-clef TITRE. S’il n’est pas utilisé, la colonne NOM_OBSERVATION contient OBSERVATION_xx avec xx variant de 1 à 99.
Sélection dans le transitoire#
Pour créer la liste des observations à faire sur le transitoire, LIST_INST, INST et PAS_OBSE ont la même signification que les opérandes de même nom servant à définir une liste d’archivage. PAS_OBSE jouant le même rôle que PAS_ARCH dans ARCHIVAGE.
L’opérande OBSE_ETAT_INIT précise si l’on doit observer les champs à l’instant initial car l’instant initial n’est pas gérable par la liste d’instants.
Les paramètres PRECISION et CRITERE permettent de gérer la précision de la sélection des instants pour l’observation.
Sélection des valeurs#
NOM_CHAM permet de définir le champ à post-traiter ainsi que ses composantes données par leur nom (NOM_CMP) ou, pour les variables internes, le nom de celles-ci (au lieu de V1, V2, …). On ne peut définir que 20 composantes au maximum par occurrence du mot-clef facteur OBSERVATION. On peut post-traiter les champs sortis par défaut par l’opérateur ou demander la sortie d’autres champs (pour l’instant, seulement EPSI_ELGA).
Pour d’autres champs, il faut faire une demande d’évolution.
La sélection pour NOM_VARI ne fonctionne que pour des champs de type VARI_ELGA.
Sélection dans l’espace#
Les mots-clefs TOUT, GROUP_NO et GROUP_MA permettent de définir le support géométrique de post-traitement:
pour des champs aux nœuds(“DEPL”, “VITE”, “ACCE”, “DEPL_ABSOLU”, “VITE_ABSOLU”, “ACCE_ABSOLU”, “CONT_NOEU”, “FORC_NODA”), on extrait la liste des nœuds
pour des champs aux points de Gauss (“SIEF_ELGA”, “VARI_ELGA” ), on extrait la liste des mailles.
Attention à ne pas utiliser TOUT=”OUI” sur des gros maillages!
Observation d’un champ ELGA#
Pour un champ ELGA, on commence par choisir les composantes ou la formule entre les composantes avec le mot-clef EVAL_CMP:
Si EVAL_CMP=”VALE”, on extrait simplement la liste des composantes donnée par NOM_CMP ou NOM_VARI .
Si EVAL_CMP=”FORMULE”, on évalue la formule donnée par le mot-clef-simple FORMULE.
Si on applique une formule sur les composantes, on aura donc une valeur et donc une observation, sinon, on aura autant d’observations que de composantes dans la liste NOM_CMP ou NOM_VARI.
Une fois évalué les composantes ou la formule sur les composantes, par le mot-clef EVAL_ELGA, on peut:
Extraire ces valeurs sur les points et sous-points d’intégration avec EVAL_ELGA=”VALE”. Dans ce cas, il faut préciser explicitement le point et le sous-point d’intégration par POINT et SOUS_POINT. Les sous-points d’intégration apparaissent pour les éléments de structures (poutres, plaques, coques, tuyaux, etc.).
Demander d’extraire le maximum EVAL_ELGA=”MAX” ou le minimum EVAL_ELGA=”MIN” sur tous les points et sous-points d’une maille.
Si on demande explicitement un point et un sous-point, on aura autant de réalisations que de points demandés, multiplié par le nombre de composantes demandées. Par contre, si on demande le maximum ou le minimum, il y a aura une seule observation par composante demandée.
Une fois évalué les composantes (ou la formule sur les composantes), ainsi que le point/sous-point d’extraction, on peut par le mot-clef EVAL_CHAM:
Extraire ces valeurs sur toutes les mailles avec EVAL_CHAM=”VALE”.
Demander d’extraire le maximum EVAL_CHAM=”MAX”, le minimum EVAL_CHAM=”MIN” ou la moyenne EVAL_CHAM=”MOY”
Demander d’extraire la valeur minimale en absolu EVAL_CHAM=”MINI_ABS” telle que MINI_ABS(-1,3,4,-12,-0.1) = 0.1
Demander d’extraire la valeur maximale en absolu EVAL_CHAM=”MAXI_ABS” telle que MAXI_ABS(-1,3,4,-12,-0.1) = 12
Voici un exemple pour extraire le maximum de la trace du tenseur des contraintes sur le GROUP_MA=”TOTO”:
trace = FORMULE(VALE='0.333*(SIXX+SIYY+SIZZ)', NOM_PARA=('SIXX','SIYY','SIZZ',));
OBSERVATION =_F( NOM_CHAM = 'SIEF_ELGA',
GROUP_MA = 'TOTO',
EVAL_CHAM = 'MAX',
NOM_CMP = ('SIXX','SIYY','SIZZ',),
EVAL_CMP = 'FORMULE',
FORMULE = trace,
EVAL_ELGA = 'MAX')
Observation d’un champ NOEU#
On commence par choisir les composantes ou la formule entre les composantes par le mot-clef EVAL_CMP:
Si EVAL_CMP=”VALE”, on extrait simplement la liste des composantes donnée par NOM_CMP
Si EVAL_CMP=”FORMULE”, on évalue la formule donnée par le mot-clef-simple FORMULE.
Si on applique une formule sur les composantes, on aura donc une valeur et donc une observation, sinon, on aura autant d’observations que de composantes dans la liste NOM_CMP.
Une fois évalué les composantes (ou la formule sur les composantes), on peut, par le mot-clef EVAL_CHAMP :
Extraire ces valeurs sur tous les noeuds avec EVAL_CHAM=”VALE”.
Demander d’extraire le maximum EVAL_CHAM = “MAX”, le minimum EVAL_CHAM = “MIN” ou la moyenne EVAL_CHAM = “MOY”.
Demander d’extraire la valeur minimale en absolu EVAL_CHAM=”MINI_ABS” telle que MINI_ABS(-1,3,4,-12,-0.1) = 0.1
Demander d’extraire la valeur maximale en absolu EVAL_CHAM=”MAXI_ABS” telle que MAXI_ABS(-1,3,4,-12,-0.1) = 12
Voici un exemple pour extraire le maximum de la composante DX du déplacement sur GROUP_NO=”TOTO”:
OBSERVATION = _F( NOM_CHAM = 'DEPL',
GROUP_NO = 'TOTO',
EVAL_CHAM = 'MAX',
NOM_CMP = ('DX',),
)
Observation d’un champ ELEM#
On commence par choisir les composantes ou la formule entre les composantes par EVAL_CMP:
Si EVAL_CMP=”VALE”, on extrait simplement la liste des composantes donnée par NOM_CMP
Si EVAL_CMP=”FORMULE”, on évalue la formule donnée par le mot-clef-simple FORMULE
Si on applique une formule sur les composantes, on aura donc une valeur et donc une observation, sinon, on aura autant d’observations que de composantes dans la liste NOM_CMP.
Une fois évalué les composantes (ou la formule sur les composantes), ainsi que le point/sous-point d’extraction, on peut, par le mot-clef EVAL_CHAMP :
Extraire ces valeurs sur toutes les mailles avec EVAL_CHAM=”VALE”.
Demander d’extraire le maximum EVAL_CHAM = “MAX”, le minimum EVAL_CHAM = “MIN” ou la moyenne EVAL_CHAM = “MOY”.
Demander d’extraire la valeur minimale en absolu EVAL_CHAM=”MINI_ABS” telle que MINI_ABS(-1,3,4,-12,-0.1) = 0.1
Demander d’extraire la valeur maximale en absolu EVAL_CHAM=”MAXI_ABS” telle que MAXI_ABS(-1,3,4,-12,-0.1) = 12
Contenu des valeurs en sortie#
La table contiendra au maximum 16 colonnes.
NOM_OBSERVATION |
K80 |
Nom donné automatiquement ou par le mot clef TITRE |
TYPE_OBJET |
K16 |
La table ne contient que des valeurs réelles donc R |
NOM_SD |
K24 |
“ “ |
NUME_REUSE |
I |
Indice de réutilisation de la table en cas de REUSE |
NUME_OBSE |
I |
Numéro d’ordre de l’observation |
INST |
R |
Instant de l’observation |
NOM_CHAM |
K16 |
Nom du champ observé |
EVAL_CHAM |
K8 |
Type d’évaluation du champ |
NOM_CMP |
K8 |
Nom de la composante observée |
NOM_VARI |
K16 |
Nom de la variable interne observée |
EVAL_CMP |
K8 |
Type d’évaluation de la composante |
NOEUD |
K8 |
Nœud où se réalise l’observation (champ aux nœuds) |
MAILLE |
K8 |
Maille où se réalise l’observation (champ aux mailles) |
EVAL_ELGA |
K8 |
Type d’évaluation des champs aux points de Gauss |
POINT |
I |
Point d’intégration où se réalise l’observation (champs aux mailles) |
SOUS_POINT |
I |
Sous-point d’intégration où se réalise l’observation (champs aux mailles) |
VALE |
R |
Valeur |
NUME_GLOBAL_NOEUD |
I |
Numéro du nœud où se réalise l’observation (champ aux nœuds) dans la numérotation globale (attention cette numérotation commence à zéro). Cette colonne n’est ajoutée que dans le cas de l’utilisation du parallélisme distribué, |
Le paramètre NUME_REUSE sert en cas d’enrichissement de la structure de données résultat. En effet, si la reprise écrase d’anciens numéros d’ordre dans la structure de données résultat (voir mot-clef ETAT_INIT), ce n’est pas le cas des valeurs dans la table d’observation, qui n’est jamais modifiée rétroactivement. On peut donc avoir deux valeurs différentes pour le même instant dans la table, la distinction se fera alors sur NUME_REUSE.
Définition du CONTACT#
◇ CONTACT = char_contact,
Le mot clé simple CONTACT permet d’activer la résolution du contact-frottement ou la prise en compte d’une liaison unilatérale. contact est un concept issu de l’opérateur [DEFI_CONTACT].
Ce mot-clé simple n’accepte qu’un seul concept. On ne peut donc pas mélanger dans un même calcul non-linéaire la résolution du contact et la prise en compte d’une liaison unilatérale. On ne peut pas non plus mélanger les différentes formulations .
Évaluation de la stabilité#
◇ CRIT_STAB = _F(
◇ OPTION = / "BANDE",
/ "CALIBRATION",
/ "PLUS_PETITE" (par défaut),
# Si: (equal_to("OPTION", 'BANDE'))
◇ CHAR_CRIT = float,
# Si: (equal_to("OPTION", 'PLUS_PETITE'))
◇ NMAX_CHAR_CRIT = int (défaut: 3),
# Si: (equal_to("OPTION", 'CALIBRATION'))
◇ CHAR_CRIT = float,
◇ COEF_DIM_ESPACE = int (défaut: 5),
◇ RIGI_GEOM = / "NON",
/ "OUI" (par défaut),
◇ MODI_RIGI = / "NON" (par défaut),
/ "OUI",
◇ TYPE = / "FLAMBEMENT" (par défaut),
/ "STABILITE",
◇ PREC_INSTAB = float (défaut: 1e-06),
◇ SIGNE = / "NEGATIF",
/ "POSITIF",
/ "POSITIF_NEGATIF" (par défaut),
# Si: (equal_to("RIGI_GEOM", 'NON'))
◇ DDL_EXCLUS = / "DAMG",
/ "DCX",
/ "DCY",
/ "DCZ",
/ "DRX",
/ "DRY",
/ "DRZ",
/ "DX",
/ "DY",
/ "DZ",
/ "GONF",
/ "GRX",
/ "H1X",
/ "H1Y",
/ "H1Z",
/ "K1",
/ "K2",
/ "K3",
/ "LAGS_C",
/ "LAG_GV",
/ "LIAISON",
/ "PHI",
/ "PRE1",
/ "PRE2",
/ "PRES",
/ "PRES11",
/ "PRES12",
/ "PRES13",
/ "PRES21",
/ "PRES22",
/ "PRES23",
/ "PRES31",
/ "PRES32",
/ "PRES33",
/ "TEMP",
/ "UI2",
/ "UI3",
/ "UI4",
/ "UI5",
/ "UI6",
/ "UO2",
/ "UO3",
/ "UO4",
/ "UO5",
/ "UO6",
/ "V11",
/ "V12",
/ "V13",
/ "V21",
/ "V22",
/ "V23",
/ "V31",
/ "V32",
/ "V33",
/ "VARI",
/ "VI2",
/ "VI3",
/ "VI4",
/ "VI5",
/ "VI6",
/ "VO2",
/ "VO3",
/ "VO4",
/ "VO5",
/ "VO6",
/ "WI1",
/ "WI2",
/ "WI3",
/ "WI4",
/ "WI5",
/ "WI6",
/ "WO",
/ "WO1",
/ "WO2",
/ "WO3",
/ "WO4",
/ "WO5",
/ "WO6",
# Si: equal_to("TYPE", 'STABILITE') and equal_to("RIGI_GEOM", 'NON')
◆ DDL_STAB = / "DAMG",
/ "DCX",
/ "DCY",
/ "DCZ",
/ "DRX",
/ "DRY",
/ "DRZ",
/ "DX",
/ "DY",
/ "DZ",
/ "GONF",
/ "GRX",
/ "H1X",
/ "H1Y",
/ "H1Z",
/ "K1",
/ "K2",
/ "K3",
/ "LAGS_C",
/ "LAG_GV",
/ "LIAISON",
/ "PHI",
/ "PRE1",
/ "PRE2",
/ "PRES",
/ "PRES11",
/ "PRES12",
/ "PRES13",
/ "PRES21",
/ "PRES22",
/ "PRES23",
/ "PRES31",
/ "PRES32",
/ "PRES33",
/ "TEMP",
/ "UI2",
/ "UI3",
/ "UI4",
/ "UI5",
/ "UI6",
/ "UO2",
/ "UO3",
/ "UO4",
/ "UO5",
/ "UO6",
/ "V11",
/ "V12",
/ "V13",
/ "V21",
/ "V22",
/ "V23",
/ "V31",
/ "V32",
/ "V33",
/ "VARI",
/ "VI2",
/ "VI3",
/ "VI4",
/ "VI5",
/ "VI6",
/ "VO2",
/ "VO3",
/ "VO4",
/ "VO5",
/ "VO6",
/ "WI1",
/ "WI2",
/ "WI3",
/ "WI4",
/ "WI5",
/ "WI6",
/ "WO",
/ "WO1",
/ "WO2",
/ "WO3",
/ "WO4",
/ "WO5",
/ "WO6",
◇ / LIST_INST = listr8,
/ PAS_CALC = int,
/ INST = float,
◇ CRITERE = / "ABSOLU",
/ "RELATIF" (par défaut),
# Si: (equal_to("CRITERE", 'RELATIF'))
◇ PRECISION = float (défaut: 1e-06),
# Si: (equal_to("CRITERE", 'ABSOLU'))
◆ PRECISION = float,
),
Le mot-clé CRIT_STAB permet de déclencher le calcul, à la fin de chaque incrément de temps, d’un critère de stabilité. Ce critère est utile pour déceler, au cours du chargement, le point à partir duquel on perd la stabilité par l’utilisation de deux critères
Par flambage dans le cas de phénomène mécanique réversibles (TYPE = “FLAMBEMENT”).
Par une étude de signe sur la dérivée seconde de l’énergie en respectant l’accroissement des degrés de liberté irréversibles dans le cas d’une mécanique dissipative (TYPE = “STABILITE”)
Cas du flambage#
Pour le flambement, le critère est alors calculé de la façon suivante. À la fin d’un pas de temps, en petites perturbations, on résout
où \({K}^{T}\) est la matrice tangente cohérente à cet instant et \({K}^{g}\) est la matrice de rigidité géométrique, calculée à partir du champ de contraintes à cet instant.
En pratique, le chargement est instable si le coefficient de charge critique \({\mu}\) vérifie \(|{\mu}|<1\) (en fait \(0<{\mu}<1\) ). On calcule les valeurs propres par la méthode de Sorensen (voir CALC_MODES). Ceci peut être assez coûteux pour les problèmes de grande taille.
Pour les grands déplacements et les grandes déformations, on résout
car \({K}^{T}\) contient alors \({K}^{g}\).
Le critère est alors un critère d’instabilité : quand \({\mu}\) change de signe (donc passe par 0) le chargement est instable. On stocke le mode propre correspondant à la plus petite charge critique (en valeur absolue) dans l’objet résultat, sous le nom MODE_FLAMB. Ce mode propre peut être extrait et visualisé (comme un champ de déplacements ou un mode propre classique). Il est normalisé à 1 sur la plus grande composante de déplacement. L’analyse de stabilité linéaire ne permettant pas de tenir compte de l’aspect suiveur de certaines forces, il faut alors utiliser CRIT_STAB.
La documentation [U2.08.04] présentent les différentes approches pour les analyses de flambement.
Cas de la stabilité#
Pour traiter le cas particulier TYPE = “STABILITE”, on impose de prendre comme matrice de rigidité géométrique la matrice identité \({K}^{g}={I}_{d}\) . On recherche ensuite le minimum de la fonctionnelle quadratique suivante
où \({K}^{T}\) est la matrice tangente cohérente à l’instant étudié et \({x}^{t}\) le vecteur transposé du champ des inconnus nodales \(x\), sous des contraintes de positivité sur les degrés de liberté de \(x\) de nature irréversible. Le signe du minimum permet ensuite de conclure sur la stabilité du chargement. Dans le cas où celui-ci est négatif, la solution est instable. Dans le cas contraire, la solution obtenue numériquement est stable. Le mode obtenu, qui est le vecteur minimisant \(C(x)\) (dit mode d’instabilité dans le cas où le minimum est négatif), et l’estimation du critère de stabilité associé sont stockés dans l’objet résultat sous le nom MODE_STAB ( CHAR_STAB = \(C(x)\) ).
Sortie des résultats#
L’ensemble des résultats est stocké dans une structure de données de type table_container de nom “ANALYSE_MODALE” attachée à la structure de données evol_noli . Les modes de flambement ( TYPE=”FLAMBEMENT” ) sont stockés comme TYPE_MODE=” MODE_FLAMB “ dans la table tandis que les modes de stabilité ( TYPE=” STABILITE “ ) y sont stockés comme TYPE_MODE=” MODE_STAB “ (voir [DYNA_NON_LINE]).
Sélection dans le transitoire#
Les instants pour lesquels on veut faire un calcul de stabilité sont donnés par une liste d’instants renseignée par LIST_INST ou par une fréquence PAS_CALC.
La sélection est contrôlée par les mots-clefs PRECISION et CRITERE, voir [U4.71.00].
En l’absence de ces mots clés le critère est calculé à tous les pas de temps.
Réglages du solveur modal#
Le mot-clé OPTION permet de choisir le type de recherche:
OPTION=”PLUS_PETITE”: les NMAX_CRIT vecteurs propres et valeurs propres correspondant aux plus petites valeurs propres;
OPTION=”BANDE”: les vecteurs propres et valeurs propres pour les chargements critiques compris dans la bande CHAR_CRIT;
OPTION=”CALIBRATION” donne juste le nombre de valeurs propres pour les chargements critiques compris dans la bande CHAR_CRIT;.
Le mot-clé COEF_DIM_ESPACE (5 est sa valeur par défaut) permet à l’utilisateur de contrôler la taille du sous-espace dans la méthode de Sorensen (la taille du sous espace est égale à la multiplication de ce coefficient par la valeur nbfreq renseignée précédemment). L’intérêt étant de pouvoir réduire cet espace dans le cas où l’on utilise en plus l’opérande DDL_STAB.
Sélection des matrices#
Le mot-clé RIGI_GEOM (“OUI” par défaut) donne le choix à l’utilisateur entre effectuer une recherche de valeurs propres généralisées avec la matrice géométrique au second membre ou non (cas des grandes déformations).
Choisir “NON” signifie que la matrice de raideur géométrique est remplacée par l’identité.
Le mot-clé MODI_RIGI (“NON” par défaut) permet de préciser si la matrice de rigidité globale (et la matrice de rigidité géométrique si elle est utilisée) doit être modifiée au niveau des degrés de liberté que l’on liste avec DDL_EXCLUS. Cela permet, par exemple, pour des modèles mixtes, de ne mener l’analyse de stabilité en excluant certains type de degré de liberté et en corrigeant les matrices de rigidité globales pour que les termes liés à ces degrés de liberté ne : viennent pas perturber la recherche d’instabilité. On donne d’autres détails dans le paragraphe consacré à DDL_EXCLUS. Si la liste de degrés de liberté exclus est vide, alors MODI_RIGI ne sert donc à rien.
Sélection des degrés de liberté#
Le mot-clé DDL_EXCLUS (liste vide par défaut) désigne l’ensemble des degrés de liberté que l’on souhaite mettre à 0 dans le second membre de la recherche de valeurs propres généralisées. Il ne peut être utilisé que sous la condition RIGI_GEOM = “NON” ou si MODI_RIGI = “OUI”.
Dans le cas RIGI_GEOM = “NON” et MODI_RIGI = “NON”, cela permet d’imposer des conditions supplémentaires de compatibilité sur les modes propres et ainsi d’effectuer une recherche sélective. Cela est particulièrement adapté aux formulations mixtes. Dans ce cas, l’élimination des multiplicateurs de Lagrange au second membre, permet d’exclure les modes parasites à dominantes Lagrangiennes et de valeurs propres négatives.
Dans le cas MODI_RIGI= “OUI”, cela permet de modifier la matrice de rigidité (et si besoin est la matrice de rigidité géométrique) de manière à mener l’analyse de stabilité en ne tenant pas compte des degrés de liberté exclus. Par exemple, on doit utiliser cette option pour les modèles fluide-structure couplés (formulation \((u,p,\phi )\) , confer documentation [R4.02.02], qui est utilisable avec DYNA_NON_LINE mais pas STAT_NON_LINE) pour exclure les degrés de liberté fluide car la matrice de rigidité assemblée globale est singulière pour ces degrés de liberté.
Pour plus de détails, l’utilisateur pourra utilement se reporter aux documentations [U2.06.11] et [U2.08.04].
Le mot-clé DDL_STAB désigne l’ensemble des degrés de liberté irréversibles dans l’étude de stabilité que l’on souhaite réaliser avec CRIT_STAB . Il ne peut être utilisé que sous les conditions : TYPE=”STABILITE” et RIGI_GEOM=”NON” . Cela permet d’effectuer une étude de signe sur la dérivée seconde de l’énergie, au chargement considéré, en ne regardant que les perturbations susceptibles d’augmenter les degrés de liberté déclarés dans DDL_STAB . Ceci afin de respecter les conditions mécaniques d’irréversibilité.
Sélection des critères#
Le mot-clé SIGNE permet de spécifier quel type de critère d’instabilité sera utilisé. Ce critère permettra de déclencher un arrêt propre (base sauvegardée) du calcul non-linéaire en cas d’instabilité, si l’utilisateur le précise, sous [DEFI_LIST_INST].
Sans cette déclaration sous DEFI_LIST_INST, même en cas d’instabilité détectée le calcul non-linéaire tentera de se poursuivre: c’est le mode par défaut. Pour les analyses de stabilité sans matrice de rigidité géométrique, le critère d’instabilité est qu’une charge critique tende vers 0, ou change de signe. Dans ce cas, le mot-clé SIGNE ne sert pas.
En revanche, pour les cas où la matrice de rigidité géométrique est utilisée, ce mot-clé SIGNE est utile. Avec la valeur par défaut SIGNE = “ POSITIF_NEGATIF” , la solution sera déclarée instable dans les cas où une charge critique devient comprise entre -1 et 1. Si l’utilisateur choisit l’option “NEGATIF” alors le domaine d’instabilité sera borné par les valeurs -1 et 0. Inversement, l’option “POSITIF” définira les valeurs 0 et 1 comme limites du domaine
d’instabilité. Le choix par défaut est le plus conservatif, mais dans certains cas où l’on peut dédouaner a priori une partie du domaine d’instabilité, alors il est pertinent de modifier le critère avec le mot-clé SIGNE. On rappelle que la charge critique calculée par CRIT_STAB, dans le cas où la matrice de rigidité géométrique est prise en compte, est égale au coefficient multiplicateur du chargement imposé qui rend le problème instable. Donc si la valeur calculée par CRIT_STAB vaut 1 cela signifie qu’on est instable pour la charge imposée. Si on obtient la valeur -1, alors l’instabilité se produira pour une charge imposée de même valeur mais de signe opposé. Donc pour des chargements imposés connus et évoluant de façon monotone, il est aisé de restreindre le domaine d’instabilité car on sait que le chargement ne peut changer de signe. En revanche, pour des chargements cycliques ou quelconques, il est plus sûr de ne pas restreindre le domaine d’instabilité.
Le mot-clé PREC_INSTAB permet de définir la tolérance relative avec laquelle on souhaite vérifier le critère d’instabilité, qui est paramétré par le mot-clé précédent SIGNE .
Calcul des énergies#
◇ ENERGIE = _F(
◇ CALCUL = "OUI",
),
Le mot-clé ENERGIE permet d’activer le calcul du bilan d’énergie, son affichage en cours de calcul et son stockage dans la table de nom PARA_CALC. Le bilan d’énergie peut être extrait de cette table à l’aide de la commande [RECU_TABLE].
Utilisation de la sous-structuration#
◇ SOUS_STRUC = _F(
◆ CAS_CHARGE = text,
◆ / TOUT = "OUI" (ou non renseigné),
/ SUPER_MAILLE = ma,
◇ FONC_MULT = fonction / formule / nappe,
),
Le mot clé facteur SOUS_STRUC permet de préciser quels sont les chargements à utiliser pour les sous-structures statiques qui font alors obligatoirement partie du modèle. En son absence, les chargements sur les sous structures sont nuls.
Ces chargements s’ajoutent aux chargements «éléments finis» qui peuvent être appliqués sur le reste du modèle. Pour plus de précision concernant l’utilisation de y sous-structures (élastiques linéaires) dans une structure non-linéaire, on se reportera à la documentation [U2.07.02] et au cas-test ssnv193a.
CAS_CHARGE donne le nom du cas de charge à utiliser. Voir opérateur [ref:MACR_ELEM_STAT <U4.62.01>].
Le mot-clé TOUT = “OUI” permet d’affecter le chargement à toutes les sous-structures du modèle.
Le mot-clé facteur SUPER_MAILLE permet de n’affecter le chargement qu’à certaines sous‑structures.
FONC_MULT=:math:{f}_{i} est la fonction du temps multiplicatrice du chargement précisé à la ième occurrence de SOUS_STRUCT.
Le comportement de ce mot clé est le même que pour son occurrence dans EXCIT.
Suivi du calcul#
Cette section regroupe les différetns outils permettant de suivre un calcul: mesure des temps, affichage, extraction de résultats, suivi de valeurs de calcul.
Suivi en temps réel de valeurs#
◇ SUIVI_DDL = _F(
◆ NOM_CHAM = / "ACCE",
/ "DEPL",
/ "EPSI_ELGA",
/ "FORC_NODA",
/ "SIEF_ELGA",
/ "VARI_ELGA",
/ "VITE",
◇ EVAL_CHAM = / "MAX",
/ "MAXI_ABS",
/ "MIN",
/ "MINI_ABS",
/ "MOY",
/ "VALE" (par défaut),
◆ / NOM_CMP = text,
/ NOM_VARI = text,
◇ EVAL_CMP = / "FORMULE",
/ "VALE" (par défaut),
# Si: (equal_to("EVAL_CMP", 'FORMULE'))
◆ FORMULE = formule,
# Si: is_in("NOM_CHAM", ('DEPL','VITE','ACCE','FORC_NODA','CONT_NOEU'))
◆ / TOUT = "OUI" (ou non renseigné),
/ NOEUD = no,
/ GROUP_NO = grno,
/ GROUP_MA = grma,
/ MAILLE = ma,
# Si: is_in("NOM_CHAM", ('SIEF_ELGA','EPSI_ELGA','VARI_ELGA'))
◆ / TOUT = "OUI" (ou non renseigné),
/ GROUP_MA = grma,
/ MAILLE = ma,
◇ EVAL_ELGA = / "MAX",
/ "MIN",
/ "VALE" (par défaut),
# Si: (equal_to("EVAL_ELGA", 'VALE'))
◆ POINT = int,
◇ SOUS_POINT = int,
◇ TITRE = text,
),
Le mot-clé SUIVI_DDL permet de post-traiter certains champs aux nœuds ou aux éléments sur des parties de modèle à toutes les itérations de Newton et les afficher dans le tableau de convergence. Le nombre simultané de SUIVI_DDL dépend des colonnes affichées et donc des fonctionnalités activées.
Le mot-clé facteur SUIVI_DDL a la même syntaxe que OBSERVATION pour l’extraction des champs, sauf que l’on ne donne pas d’informations sur les instants à extraire, puisqu’on le réalise à chaque itération de Newton (il n’y a pas les mots clefs LIST_INST/INST/PAS_OBSE/CRITERE/PRECISION).
Le mot-clé TITRE attend une liste de trois chaines au maximum et permet de nommer la colonne du tableau d’affichage. Les chaines sont tronquées à 16 caractères.
Mesure des temps#
⟐ MESURE = _F(
◇ TABLE = / "NON" (par défaut),
/ "OUI",
◇ UNITE = unit,
),
Principes généraux#
La commande MESURE permet de sortir des informations de mesure sur le calcul:
soit dans une table de nom “STAT” récupérable par [RECU_TABLE] (voir mot-clef OBSERVATION)
soit dans un fichier au format CSV dont l’unité logique est donnée par le mot-clef UNITE
A noter que ces mesures sont également sorties dans le fichier .mess habituel.
Contenu de la table ou du fichier généré#
La table est indexée par le pas de temps: présence d’une colonne “INST” de type réel. Chaque type de mesure peut exister sous deux formes (simultanément ou pas):
un temps CPU (elapse): dans ce cas, la colonne contiendra un réel et aura pour nom le type préfixé par Time_;
un nombre occurrences (par exemple le nombre d’itérations de Newton): dans ce cas, la colonne contiendra un entier et aura pour nom le type préfixé par Count_;
un encombrement mémoire (vmpeak, en Mo): dans ce cas la colonne contiendra un entier et aura pour nom le type préfixé par Count_;
Type de mesure |
Temps |
Occurrences |
Description |
Compute |
Oui |
Non |
Temps de calcul total |
Lost_Time |
Oui |
Non |
Temps «perdu» à cause des découpes du pas de temps |
Time_Step |
Oui |
Oui |
Temps et nombre total de pas de temps |
Newt_Iter |
Oui |
Oui |
Temps moyen d’une itération de Newton par pas de temps et nombre d’itérations par pas de temps |
Store |
Oui |
Oui |
Temps pour l’archivage et nombre d’archivages au total |
Post |
Oui |
Oui |
Temps pris pour le post-traitement (flambement, … ) et nombre de post-traitements au total |
Integrate |
Oui |
Oui |
Temps pour l’intégration du comportement et nombre d’intégrations de comportement par pas de temps |
Factor |
Oui |
Oui |
Temps pour la factorisation de la matrice et nombre de factorisations par pas de temps |
2nd_Member |
Oui |
Oui |
Temps pour la construction du second membre et nombre de constructions par pas de temps |
Solve |
Oui |
Oui |
Temps pour la résolution des systèmes linéaires et nombre de résolutions par pas de temps |
Cont_Geom |
Oui |
Oui |
Nombre de réactualisations géométriques et temps passé dans l’appariement pour le contact |
Cont_Algo |
Oui |
Oui |
Nombre d’itérations de contact et temps passé dans la résolution (méthodes discrètes) |
Cont_Prep |
Oui |
Oui |
Nombre de préparations du contact et temps passé dans ces préparations (pour méthode continue: création des éléments, création et remplissage du champ d’entrée, etc.) |
Cont_Elem |
Oui |
Oui |
Nombre et temps passé dans les calculs élémentaires pour le contact (méthode continue) |
Matr_Asse |
Oui |
Non |
Temps passé dans la création des matrices |
Cont_NCont |
Non |
Oui |
Nombre de nœuds/points/patchs en contact |
Cont_NFric |
Non |
Oui |
Nombre de nœuds/points/patchs en frottement |
LineSearch |
Non |
Oui |
Nombre d’itérations de recherche linéaire |
Cont_Cycl1 |
Non |
Oui |
Nombre de cyclages de type contact (voir R5.03.52) |
Cont_Cycl2 |
Non |
Oui |
Nombre de cyclages de type glissement/adhérence (voir R5.03.52) |
Cont_Cycl3 |
Non |
Oui |
Nombre de cyclages de type glissement avant/arrière (voir R5.03.52) |
Cont_Cycl4 |
Non |
Oui |
Nombre de cyclages de type flip/flop (méthode continue, voir R5.03.52) |
Other |
Oui |
Non |
Temps passé dans les autres opérations que celles mesurées ci-dessus |
Memory |
Non |
Oui |
Encombrement mémoire en Mo |
Exemples:
Paramètre Count_Cont_NCont: nombre de nœuds en contact;
Paramètre Time_Factor : temps passé dans la factorisation.
Affichages#
⟐ AFFICHAGE = _F(
◇ INFO_RESIDU = / "NON" (par défaut),
/ "OUI",
◇ INFO_TEMPS = / "NON" (par défaut),
/ "OUI",
◇ UNITE = unit,
◇ PAS = int,
),
Le mot-clef facteur AFFICHAGE permet de personnaliser l’affichage du tableau de convergence dans y STAT_NON_LINE et DYNA_NON_LINE.
Si ce mot-clef n’est pas renseigné, le tableau est construit suivant les différentes options de calcul (recherche linéaire, pilotage, contact, etc.) et avec INFO_RESIDU=”NON”.
Si UNITE est renseignée, le tableau de convergence sera dupliqué dans le fichier d’unité unit, au format .csv (le séparateur étant la virgule).
PAS indique la fréquence de réactualisation de l’affichage dans le fichier message. Cet opérande permet de réduire le volume des impressions, particulièrement en dynamique explicite. Il n’a pas d’influence sur la réactualisation du fichier au format .csv (mot-clef UNITE).
Le mot-clef INFO_RESIDU permet d’ajouter une colonne pour chaque résidu évalué (RESI_GLOB_RELA, RESI_GLOB_MAXI, RESI_COMP_RELA et RESI_REFE_RELA). Cette colonne indiquera le nœud où le résidu est maximum, ce qui peut aider l’utilisateur lorsqu’il y a des difficultés de convergence. Par exemple, pour voir si le matériau a été mal défini avec une valeur incorrecte sur un élément.
Le mot-clef INFO_TEMPS permet d’ajouter une colonne qui donner le temps passé dans l’itération de Newton.