4. 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.

4.1. 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 ».

4.2. 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.

4.3. 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).