u4.54.02 Opérateur THER_NON_LINE#

Syntaxe#

Détail de la syntaxe

evol_ther = THER_NON_LINE(
    ◇ reuse = <objet de RESULTAT>,
    ◇ & RESULTAT = evol_ther,
    ◆ MODELE = modele,
    ◆ CHAM_MATER = cham_mater,
    ◇ CARA_ELEM = cara_elem,
    ⟐ COMPORTEMENT = _F(
         ◇ RELATION = / "THER_HYDR",
                      / "THER_NL" (par défaut),
         ◆ / TOUT = "OUI" (ou non renseigné),
           / GROUP_MA = list[grma],
      ),
    ◆ EXCIT = _F(
         ◆ CHARGE = char_cine_ther / char_ther,
         ◇ FONC_MULT = fonction / formule / nappe,
         ◇ TYPE_CHARGE = "FIXE_CSTE",
      ),
    ⟐ AFFICHAGE = _F(
         ◇ INFO_RESIDU = / "NON" (par défaut),
                         / "OUI",
         ◇ INFO_TEMPS = / "NON" (par défaut),
                        / "OUI",
         ◇ UNITE = unit,
         ◇ PAS = int,
      ),
    ◇ METHODE = / "MODELE_REDUIT",
                / "NEWTON" (par défaut),
                / "NEWTON_KRYLOV",
                / "RASPEN",
    # Si: equal_to("METHODE", 'NEWTON') or equal_to("METHODE", 'NEWTON_KRYLOV') or equal_to("METHODE", 'RASPEN')
        ⟐ NEWTON = _F(
             ◇ REAC_ITER = int (défaut: 0),
             ◇ REAC_INCR = int (défaut: 1),
             ◇ PREDICTION = "TANGENTE",
             ◇ MATRICE = "TANGENTE",
          ),
        ◇ RECH_LINEAIRE = _F(
             ◇ METHODE = "CORDE",
             ◇ 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),
          ),
    # Si: equal_to("METHODE", 'MODELE_REDUIT')
        ⟐ MODELE_REDUIT = _F(
             ◇ REAC_ITER = int (défaut: 0),
             ◇ REAC_INCR = int (défaut: 1),
             ◆ BASE_PRIMAL = mode_empi,
             ◇ DOMAINE_REDUIT = / "NON" (par défaut),
                                / "OUI",
             # Si: (equal_to("DOMAINE_REDUIT", 'OUI'))
                 ◆ GROUP_NO_INTERF = grno,
                 ◇ CORR_COMPLET = / "NON" (par défaut),
                                  / "OUI",
                 # Si: (equal_to("CORR_COMPLET", 'OUI'))
                     ◆ GROUP_NO_ENCASTRE = grno,
                     ◇ COEF_PENA = float (défaut: 1000000.0),
          ),
    ◇ TYPE_CALCUL = / "STAT",
                    / "TRAN" (par défaut),
    # Si: (equal_to("TYPE_CALCUL", 'TRAN'))
        ◆ ETAT_INIT = _F(
             ◆ / STAT = "OUI" (ou non renseigné),
               / EVOL_THER = evol_ther,
               / CHAM_NO = cham_no,
               / VALE = float,
             # Si: exists("EVOL_THER")
                 ◇ NUME_ORDRE = 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,
          ),
        ⟐ SCHEMA_TEMPS = _F(
             ◇ SCHEMA = "THETA",
             # Si: equal_to("SCHEMA", 'THETA')
                 ◇ THETA = float (défaut: 0.57),
          ),
    # Si: (equal_to("TYPE_CALCUL", 'STAT'))
        ⟐ ETAT_INIT = _F(
             ◇ STAT = "OUI",
          ),
    ◆ 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,
      ),
    ⟐ CONVERGENCE = _F(
         ◆ | RESI_GLOB_MAXI = float,
           | RESI_GLOB_RELA = float,
         ◇ ITER_GLOB_MAXI = int (défaut: 10),
      ),
    ⟐ SOLVEUR = _F(
         ◇ METHODE = / "GCPC",
                     / "LDLT",
                     / "MULT_FRONT",
                     / "MUMPS" (par défaut),
                     / "PETSC",
         # Si: equal_to("METHODE", 'MULT_FRONT')
             ◇ RENUM = / "MD",
                       / "MDA" (par défaut),
             ◇ NPREC = int (défaut: 8),
             ◇ ELIM_LAGR = / "NON" (par défaut),
                           / "OUI",
             ◇ STOP_SINGULIER = / "NON",
                                / "OUI" (par défaut),
         # Si: equal_to("METHODE", 'LDLT')
             ◇ RENUM = "RCMK",
             ◇ NPREC = int (défaut: 8),
             ◇ ELIM_LAGR = / "NON" (par défaut),
                           / "OUI",
             ◇ STOP_SINGULIER = / "NON",
                                / "OUI" (par défaut),
         # Si: equal_to("METHODE", 'MUMPS')
             ◇ RENUM = / "AMD",
                       / "AMF",
                       / "AUTO" (par défaut),
                       / "METIS",
                       / "PARMETIS",
                       / "PORD",
                       / "PTSCOTCH",
                       / "QAMD",
                       / "SCOTCH",
             ◇ NPREC = int (défaut: 8),
             ◇ ELIM_LAGR = / "LAGR2" (par défaut),
                           / "NON",
                           / "OUI",
             ◇ STOP_SINGULIER = / "NON",
                                / "OUI" (par défaut),
             ◇ TYPE_RESOL = / "AUTO" (par défaut),
                            / "NONSYM",
                            / "SYMDEF",
                            / "SYMGEN",
             ◇ ACCELERATION = / "AUTO" (par défaut),
                              / "FR",
                              / "FR+",
                              / "FR++",
                              / "LR",
                              / "LR+",
                              / "LR++",
             ◇ LOW_RANK_SEUIL = float (défaut: 0.0),
             ◇ PRETRAITEMENTS = / "AUTO" (par défaut),
                                / "SANS",
             ◇ POSTTRAITEMENTS = / "AUTO" (par défaut),
                                 / "FORCE",
                                 / "MINI",
                                 / "SANS",
             ◇ PCENT_PIVOT = int (défaut: 35),
             ◇ REDUCTION_MPI = int (défaut: 0),
             ◇ NB_RHS = int (défaut: 1),
             ◇ RESI_RELA = float (défaut: -1.0),
             ◇ GESTION_MEMOIRE = / "AUTO" (par défaut),
                                 / "EVAL",
                                 / "IN_CORE",
                                 / "OUT_OF_CORE",
             ◇ FILTRAGE_MATRICE = float (défaut: -1.0),
             ◇ MIXER_PRECISION = / "NON" (par défaut),
                                 / "OUI",
             ◇ MATR_DISTRIBUEE = / "NON" (par défaut),
                                 / "OUI",
         # Si: equal_to("METHODE", 'GCPC')
             ◇ ELIM_LAGR = / "NON" (par défaut),
                           / "OUI",
             ◇ PRE_COND = / "LDLT_DP",
                          / "LDLT_INC" (par défaut),
                          / "LDLT_SP",
             ◇ RESI_RELA = float (défaut: 1e-06),
             ◇ NMAX_ITER = int (défaut: 0),
             # Si: equal_to("PRE_COND", 'LDLT_INC')
                 ◇ RENUM = "RCMK",
                 ◇ NIVE_REMPLISSAGE = int (défaut: 0),
             # Si: is_in("PRE_COND", ('LDLT_SP', 'LDLT_DP'))
                 ◇ RENUM = / "METIS",
                           / "PARMETIS" (par défaut),
                           / "SANS",
                 ◇ REAC_PRECOND = int (défaut: 30),
                 ◇ PCENT_PIVOT = int (défaut: 20),
                 ◇ GESTION_MEMOIRE = / "AUTO" (par défaut),
                                     / "IN_CORE",
                 ◇ LOW_RANK_SEUIL = float (défaut: 0.0),
         # Si: equal_to("METHODE", 'PETSC')
             ◇ ELIM_LAGR = / "NON" (par défaut),
                           / "OUI",
             ◇ MATR_DISTRIBUEE = / "NON" (par défaut),
                                 / "OUI",
             ◇ ALGORITHME = / "CG",
                            / "CR",
                            / "FGMRES" (par défaut),
                            / "GCR",
                            / "GMRES",
                            / "GMRES_LMP",
             ◇ OPTION_PETSC = text (défaut: ""),
             ◇ PRE_COND = / "BLOC_LAGR",
                          / "BOOMER",
                          / "FIELDSPLIT",
                          / "GAMG",
                          / "HPDDM",
                          / "JACOBI",
                          / "LDLT_DP",
                          / "LDLT_INC",
                          / "LDLT_SP" (par défaut),
                          / "ML",
                          / "SANS",
                          / "SOR",
                          / "UTILISATEUR",
             ◇ RESI_RELA = float (défaut: 1e-06),
             ◇ NMAX_ITER = int (défaut: 0),
             # Si: equal_to("PRE_COND", 'LDLT_INC')
                 ◇ RENUM = "RCMK",
                 ◇ NIVE_REMPLISSAGE = int (défaut: 0),
                 ◇ REMPLISSAGE = float (défaut: 1.0),
             # Si: is_in("PRE_COND", ('LDLT_SP', 'LDLT_DP'))
                 ◇ RENUM = / "METIS",
                           / "PARMETIS" (par défaut),
                           / "SANS",
                 ◇ REAC_PRECOND = int (défaut: 30),
                 ◇ PCENT_PIVOT = int (défaut: 20),
                 ◇ GESTION_MEMOIRE = / "AUTO" (par défaut),
                                     / "IN_CORE",
                 ◇ LOW_RANK_SEUIL = float (défaut: 0.0),
             # Si: equal_to("PRE_COND", 'ML')
                 ◇ RENUM = "SANS",
             # Si: equal_to("PRE_COND", 'BOOMER')
                 ◇ RENUM = "SANS",
             # Si: equal_to("PRE_COND", 'GAMG')
                 ◇ RENUM = "SANS",
             # Si: equal_to("PRE_COND", 'HPDDM')
                 ◇ RENUM = "SANS",
             # Si: equal_to("PRE_COND", 'BLOC_LAGR')
                 ◇ RENUM = "SANS",
             # Si: is_in("PRE_COND", ('FIELDSPLIT'))
                 ◇ RENUM = "SANS",
                 ◇ PARTITION_CMP = list[int],
                 ◇ NOM_CMP = list[text],
             # Si: is_in("PRE_COND", ('UTILISATEUR'))
                 ◇ KSP_UTIL = not_checked,
                 ◇ RENUM = "SANS",
             # Si: is_in("PRE_COND", ('JACOBI','SOR','SANS'))
                 ◇ RENUM = / "RCMK",
                           / "SANS" (par défaut),
      ),
    ⟐ ARCHIVAGE = _F(
         ◆ / PAS_ARCH = int,
           / LIST_INST = listr8,
           / INST = list[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 = list[text] (défaut: "('RESI_NOEU', 'RESI_RELA_NOEU')"),
      ),
    ◇ OBSERVATION = _F(
         ◆ / TOUT = "OUI" (ou non renseigné),
           / NOEUD = list[no],
           / GROUP_NO = list[grno],
           / GROUP_MA = list[grma],
           / MAILLE = list[ma],
         ◇ 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 = list[text],
         ◇ EVAL_CMP = / "FORMULE",
                      / "VALE" (par défaut),
         ◇ INST = list[float],
         ◇ LIST_INST = listr8,
         ◇ PAS_OBSE = int,
         ◇ CRITERE = / "ABSOLU",
                     / "RELATIF" (par défaut),
         ◆ NOM_CHAM = "TEMP" (ou non renseigné),
         # Si: (equal_to("EVAL_CMP", 'FORMULE'))
             ◆ FORMULE = formule,
         # Si: (equal_to("CRITERE", 'RELATIF'))
             ◇ PRECISION = float (défaut: 1e-06),
         # Si: (equal_to("CRITERE", 'ABSOLU'))
             ◆ PRECISION = float,
      ),
    ◇ TITRE = text,
    ◇ INFO = / 1 (par défaut),
             / 2,
)


◆ : obligatoire
◇ : optionnel
⟐ : présent par défaut
& : ensemble
/ : un seul parmi
| : plusieurs choix possibles

Paramètres généraux#

◆ MODELE = modele,
◆ CHAM_MATER = cham_mater,
◇ CARA_ELEM = cara_elem,
◇ INFO = / 1,
        / 2,
◇ 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 thermique. La structure de données vient de la commande [AFFE_MODELE]. Il est toujours obligatoire.

Les problèmes de thermique linéaire peuvent être traités avec des modèles utilisant les éléments finis 3D, 2D ou AXIS.

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

CARA_ELEM est seulement nécessaire dans le cas d’une résolution de thermique non-linéaire avec matériau orthotrope (THER_NL_ORTH). Il permet alors de transmettre à l’opérateur de résolution la définition des axes locaux du repère d’orthotropie dans le milieu 2D ou 3D (commande [AFFE_CARA_ELEM], mot clé MASSIF).

Titre#

Le mot-clef TITRE permet de donner un titre que l’on veut donner au résultat stocké dans temper, structure de données de type evol_ther [U4.03.01].

Gestion de la verbosité#

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

Application des chargements et des conditions limites#

Le mot-clef facteur EXCIT permettant de définir plusieurs chargements ou conditions limites. Pour chaque occurrence du mot-clef facteur, on définit CHARGE éventuellement multipliée par une fonction de temps FONC_MULT.

Le mot-clef CHARGE est un concept de type charge produit par [AFFE_CHAR_THER]. Comme pour la mécanique, il est également possible de définir une charge de type «degré de liberté imposé», ici la température, par [AFFE_CHAR_CINE].

Remarque:: Pour chaque occurrence du mot-clef facteur EXCIT les différents concepts char utilisés doivent être construits sur le même modèle.

Le mot-clef FONC_MULT est un coefficient multiplicatif fonction du temps (concept de type fonction, nappe ou formule) appliqué à la charge.

Remarque:: L’utilisation concomitante de FONC_MULT avec une charge contenant des chargements thermiques dépendant de la température (c’est-à-dire pour des chargements de type ECHANGE, ECHANGE_PAROI, RAYONNEMENT, SOUR_NL ou FLUNL) est interdite.

Paramétrisation du calcul#

Mot-clef TYPE_CALCUL#

Le calcul est transitoire si TYPE_CALCUL = TRAN ou stationnaire si TYPE_CALCUL=’STAT’. Dans le cas d’un calcul transitoire, il faut préciser le calcul de l’état initial dans ETAT_INIT.

Mot-clef INCREMENT#

Le mot-clef INCREMENT permet de définir les instants de calcul qui déterminent les intervalles de temps pris pour intégrer l’équation différentielle.

Les opérandes du mot clé INCREMENT ont la même signification que dans l’opérateur [STAT_NON_LINE].

Remarque :: La liste d’instants contient obligatoirement au moins deux instants sinon un message d’erreur apparaît. Néanmoins cette obligation disparaît lorsqu’on fait un calcul stationnaire (mot-clef STATIONNAIRE dans ETAT_INIT). Dans ce cas le résultat de calcul ne contiendra que l’instant initial, calculé avec l’hypothèse de stationnarité.

Mot-clef SCHEMA_TEMPS#

Ce mot-clef n’est disponible que dans le cas d’un calcul transitoire (TYPE_CALCUL = ’TRAN’).

L’argument theta est le paramètre \(theta\) de la thêta-méthode appliquée au problème transitoire. Il doit être compris entre 0 (méthode explicite) et 1 (méthode totalement implicite). En l’absence du mot clé, la valeur utilisée est \(\theta =0.57\), un peu supérieure à \(\theta =0.5\) correspondant au schéma de Crank-Nicholson. L’incidence du choix de theta sur la stabilité de la méthode est détaillée dans [R5.02.02].

Réglages des solveurs non-linéaires#

◇ METHODE =/ "MODELE_REDUIT",
            / "NEWTON" (par défaut),
            / "NEWTON_KRYLOV",
            / "RASPEN",

Le mot-clef METHODE permet de choisir la méthode de résolution du problème incrémental non linéaire.

Méthodes de Newton#

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

Avec “NEWTON_KRYLOV”, on utilise une version inexacte de l’algorithme de Newton-Raphson ; la précision des résolutions de systèmes linéaires par une méthode itérative est adaptée au cours de chaque pas de chargement.

Modèle réduit#

Pour 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éduire préalablement (commande [DEFI_BASE_REDUITE]).

Les mots-clefs MATRICE, PREDICTION, REAC_ITER et REAC_INCR ont la même signification et le même usage que dans le mot-clef facteur NEWTON.

Il est nécessaire de fournir une base empirique dans le mot-clef BASE_PRIMAL construite sur les températures (grâce à l’opérateur [DEFI_BASE_REDUITE]). Cette base doit avoir été construite sur le même modèle et le même maillage que le calcul THER_NON_LINE.

La réduction de modèle n’est pas compatible avec les fonctionnalités suivantes:

La recherche linéaire;
Les conditions limites dualisées ([AFFE_CHAR_THER], il faut utiliser [AFFE_CHAR_CINE]).

Il est possible d’activer l’hyper-réduction qui utilise une méthode de type DEIM avec 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 à l’aide du mot-clef GROUP_NO_INTERF.

Méthode `RASPEN`#

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

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

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

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

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

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

Réglages de la convergence#

Critère de convergence#

Le mot-clef facteur CONVERGENCE permet de contrôler les paramètres de convergence du calcul soit avec RESI_GLOB_RELA, soit avec RESi_GLOB_MAXI.

Remarque:: Si aucun des deux opérandes suivants n’est présent, alors tout se passe comme si RESI_GLOB_RELA = 1.E-6

Pour RESI_GLOB_MAXI= \(\varepsilon_{max}\), l’algorithme continue les itérations globales tant que

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

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= \(\varepsilon_{rel}\), l’algorithme continue les itérations globales tant que

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

où \(L\) est le vecteur du chargement imposé.

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.

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

◇ RESULTAT = evol_ther,

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(
        ◆ / STAT = "OUI" (ou non renseigné),
        / EVOL_THER = evol_ther,
        / CHAM_NO = cham_no,
        / VALE = float,
        # Si: exists("EVOL_THER")
            ◇ NUME_ORDRE = 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 d’un calcul transitoire. Contrairement au cas de la mécanique, cet état initial est obligatoire, il n’y a pas de valeur par défaut.

Calcul stationnaire#

Si STAT = « OUI », alors valeur initiale du champ de température est alors le résultat d’un calcul stationnaire préalable. C’est le mode par défaut.

Champ de température#

Le mot-clef VALE permet de définir une valeur initiale de la température constante sur toute la structure tandis que le mot-clef CHAM_NO la définit par un champ nodal de température (résultat de l’opérateur [CREA_CHAMP]) par exemple.

On peut également utiliser le champ de température initiale par extraction d’un résultat evol_ther donné par le mot-clef EVOL_THER. On peut alors donner le numéro d’ordre NUME_ORDRE ou l’instant INST du champ à extraire de cette structure de données. Si NUME_ORDRE ou INST ne sont pas remplis, on prend le dernier numéro archivé existant dans evol_ther.

Remarque :: Attention, il s’agit du numéro d’ordre dans la structure de donnée lue en reprise par le mot-clef EVOL_THER précédent. Si cette structure de donnée a été calculée avec une liste d’instants différente de celle utilisée sous le mot-clef facteur INCREMENT de la résolution courante, il est impératif de renseigner NUME_INST_INIT sous INCREMENT, la même valeur de numéro d’ordre correspondant à des instants physiques différents. Dans le cas où les deux listes d’instants sont identiques, on peut se dispenser de renseigner deux fois le même numéro d’ordre, sous ETAT_INIT et sous INCREMENT.

Les mots-clefs PRECISION et CRITERE permettent de sélectionner finement le champ à partir de la valeur de l’instant donné par INST. Voir [U4.71.00].

Archivage des champs#

Le mot-clef ARCHIVAGE est facultatif : par défaut, l’ensemble des champs calculés pour tous les pas calculés est archivé dans le concept resultat issu de la commande. Il sert à stocker certains numéros d’ordre dans une structure de données resultat et/ou exclure du stockage certains champs.

Ce mot-clef est identique à son équivalent pour l’opérateur [STAT_NON_LINE].

Remarque:: En cas d’arrêt du calcul par manque de temps CPU, les pas de temps précédemment calculés sont sauvegardés dans la base.

La commande [CALC_CHAMP] permet de calculer les flux de chaleur, aux points d’intégration ou aux nœuds, à partir du champ aux nœuds de température ainsi obtenu par THER_LINEAIRE.

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#

⟐ COMPORTEMENT = _F(
         ◇ RELATION = / "THER_HYDR",
                      / "THER_NL" (par défaut),
         ◆ / TOUT = "OUI" (ou non renseigné),
           / GROUP_MA = list[grma],
      ),

Les comportements non-linéaires sont décrits par le mot-clef facteur répétable COMPORTEMENT. Le mot-clef GROUP_MA spécifie les mailles sur lesquelles la relation de comportement est appliquée. Contrairement à la mécanique, le comportement “THER_NL” est nécessairement appliqué à tout le maillage, option TOUT : “OUI”, option par défaut, qui est en fait, dans le cas général, transparente pour l’utilisateur.

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

La thermique non-linéaire
Le calcul d’hydratation
Le calcul de séchage (traité par l’opérateur [SECH_NON_LINE])

Remarque :: Si le mot-clef COMPORTEMENT est absent, on effectue un calcul de thermique non linéaire « standard ».

Thermique non-linéaire#

Quand RELATION=”THER_NL”, il s’agit de la résolution thermique non linéaire standard.

Modélisations supportées:

milieux continus 3D : 3D
milieux continus 2D : 2D et AXIS

Calcul d’hydratation#

Quand RELATION=”THER_HYDR”, on résoud l’équation de la chaleur avec un terme source supplémentaire \(Q \dot{\xi}\) où \(Q\) est la chaleur d’hydratation, supposée constante. La variable d’hydratation \(\xi\) est solution de la loi d’évolution non linéaire, résolue simultanément au problème de thermique:

\[\dot{\xi} = A(\xi ) \exp \left( -\frac{E}{RT} \right)\]

On se reportera à la documentation de l’opérateur [DEFI_MATERIAU] pour la signification des différents paramètres.

A l’instant initial du calcul, la variable d’hydratation prend pour valeur le champ trouvé sous le nom “HYDR_ELNO” dans la structure de données evol_ther définie sous ETAT_INIT. Par défaut, l’état hydrique initial est pris vierge \(\xi =0\) .

Modélisations supportées:

milieux continus 3D : 3D
milieux continus 2D : 2D et AXIS

Suivi du calcul#

Cette section regroupe les différents outils permettant de suivre un calcul: observation et affichage.

Observation#

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-clef ARCHIVAGE (où on stocke tous les champs sur tout le modèle). Il sert essentiellement à des économies de stockage.

Ce mot-clef est répétable et permet la création d’une table d’observation de même nom que le concept résultat de THER_NON_LINE.

Pour la description de la syntaxe de ce mot-clé facteur, se reporter à la documentation du mot-clé équivalent de [DYNA_NON_LINE].

Affichages#

Le mot-clef facteur AFFICHAGE permet de personnaliser l’affichage du tableau de convergence.

Si ce mot-clef n’est pas renseigné, le tableau est construit suivant les différentes options de calcul et avec INFO_RESIDU=”NON”.

Pour la description de la syntaxe de ce mot-clé facteur, se reporter à la documentation du mot-clé équivalent de [STAT_NON_LINE].

u4.54.02 Opérateur THER_NON_LINE#

Syntaxe#

Paramètres généraux#

Titre#

Gestion de la verbosité#

Application des chargements et des conditions limites#

Paramétrisation du calcul#

Mot-clef TYPE_CALCUL#

Mot-clef INCREMENT#

Mot-clef SCHEMA_TEMPS#

Réglages des solveurs non-linéaires#

Méthodes de Newton#

Modèle réduit#

Méthode RASPEN#

Réglages de la convergence#

Critère de convergence#

Gestion des itérations#

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

Définition d’un état initial#

Calcul stationnaire#

Champ de température#

Archivage des champs#

Réglages du solveur linéaire#

Comportements non-linéaires#

Thermique non-linéaire#

Calcul d’hydratation#

Suivi du calcul#

Observation#

Affichages#

Méthode `RASPEN`#