u4.52.06 Opérateur MODE_NON_LINE#

Syntaxe#

Détail de la syntaxe
table_container = MODE_NON_LINE(
    ◇ reuse = <objet de ETAT_INIT/MODE_NON_LINE>,
    ◆ ETAT_INIT = _F(
         ◆ / MODE_LINE = mode_meca,
           / MODE_NON_LINE = table_container,
         ◆ NUME_ORDRE = int,
         ◇ DIR_EVOLUTION = / -1 (par défaut),
                           / 1,
         ◇ COEF_AMPL = float (défaut: 1),
      ),
    ◇ CHOC = _F(
         ◇ OBSTACLE = / "BI_PLAN",
                      / "CERCLE",
                      / "PLAN",
         # Si: equal_to("OBSTACLE", 'CERCLE')
             ◆ NOM_CMP = / "DX",
                         / "DY",
                         / "DZ",
             ◇ ORIG_OBST = float (défaut: (0.0, 0.0, 0.0)),
         # Si: equal_to("OBSTACLE", 'BI_PLAN')
             ◆ NOM_CMP = / "DX",
                         / "DY",
                         / "DZ",
         # Si: equal_to("OBSTACLE", 'PLAN')
             ◆ NOM_CMP = / "DX",
                         / "DY",
                         / "DZ",
         ◆ GROUP_NO = grno,
         ◆ JEU = float,
         ◆ RIGI_NOR = float,
         ◇ PARA_REGUL = float (défaut: 0.005),
      ),
    ◆ MATR_RIGI = matr_asse_depl_r,
    ◆ MATR_MASS = matr_asse_depl_r,
    ◆ RESOLUTION = _F(
         ◇ METHODE = "EHMAN",
         # Si: equal_to("METHODE", 'EHMAN')
             ◆ NB_HARM_LINE = int,
             ◇ NB_HARM_NONL = int (défaut: 201),
             ◆ NB_BRANCHE = int,
             ◆ NB_PAS_MAN = int,
             ◇ NB_ORDRE_MAN = int (défaut: 20),
             ◇ PREC_MAN = float (défaut: 1e-09),
             ◇ PREC_NEWTON = float (défaut: 1e-08),
             ◇ ITER_NEWTON_MAXI = int (défaut: 15),
             ◇ CRIT_ORDR_BIFURCATION = int (défaut: 3),
             ◇ RESI_RELA_BIFURCATION = float (défaut: 0.0001),
      ),
    ⟐ SOLVEUR = _F(
         ◇ METHODE = "MUMPS",
         # 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",
         # 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",
             ◇ 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 = int,
                 ◇ NOM_CMP = 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),
      ),
    ◇ INFO = int (défaut: 1),
)


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

Opérandes#

Mot clé MATR_MASS et MATR_RIGI#

♦    MATR_MASS

Matrice assemblée réelle, symétrique de type [matr_asse_depl_r].

♦    MATR_RIGI

Matrice assemblée réelle, symétrique de type [matr_asse_depl_r].

Mot clé ETAT_INIT#

◊    ETAT_INIT

Sous ce mot-clé facteur, on peut renseigner une solution périodique pour initialiser l’algorithme de calcul des modes non-linéaires.

Opérande MODE_LINE#

◊    MODE_LINE

Structure de type mode_mecaissue d’un calcul avec l’opérateur CALC_MODES. Ce mot-clé n’est pas valide si le mot-clé MODE_NON_LINEest présent.

Opérande MODE_NON_LINE#

◊    MODE_NON_LINE

Structure de type table_container issue d’un calcul avec l’opérateur MODE_NON_LINE. Ce mot-clé n’est pas valide si le mot-clé MODE_LINE est présent.

Opérande NUME_ORDRE#

◊    NUME_ORDRE

Si le mot-clé MODE_LINE est présent alors num_ordr indique le numéro d’ordre du mode propre linéaire issue de mode_line choisi pour initialiser l’algorithme.

Si le mot-clé MODE_NON_LINE est présent alors num_ordrindique le numéro d’ordre de la solution périodique issue de resu_inchoisi pour initialiser l’algorithme.

Opérande DIR_EVOLUTION#

◊    DIR_EVOLUTION

Si 1alors on va dans le même sens que le premier vecteur tangent calculé.

Si -1 alors on va dans le sens contraire à le premier vecteur tangent calculé.

La valeur par défaut est -1.

Opérande COEF_AMPL#

◊    COEF_AMPL

ampl est l’amplitude maximale donnée à la solution périodique choisi pour initialiser l’algorithme.

Cette valeur est utile lorsqu’on initialise avec un mode propre linéaire, où l’amplitude maximale doit être petite pour que l’algorithme converge.

La valeur par défaut est 1.

Mot clé CHOC#

◊    CHOC

Sous ce mot-clé facteur, on renseigne la configuration et les paramètres physiques correspondant à la non-linéarité de choc que l’on veut imposer.

Opérande JEU#

♦    JEU

jeu est la distance entre le nœud et la butée élastique sur laquelle celui-ci peut rentrer en contact.

Opérande RIGI_NOR#

♦    RIGI_NOR

alpha est la raideur de la butée élastique.

Opérande PARA_REGUL#

◊    PARA_REGUL

eta est le paramètre permettant de régulariser la loi de comportement qui régit la relation entre le nœud et la butée élastique.

La valeur par défaut est 0.005.

Opérande GROUP_NO#

◊    GROUP_NO

grno est le nom du groupe de nœud sur lequel se trouve la non-linéarité. A noter que grnone doit contenir qu’un seul nœud.

Opérande OBSTACLE#

◊    OBSTACLE

Trois possibilités:

“PLAN” qui correspond à une butée élastique unilatérale.

“BI_PLAN” qui correspond à une butée élastique bilatérale.

“CERCLE” qui correspond à une butée élastique de forme circulaire.

Opérande ORIG_OBST#

◊    ORIG_OBST

Ce mot-clé est disponible seulement dans le cas où OBSTACLE = “CERCLE”. Il définit les coordonnées cartésiennes du centre du cercle dans le repère local dont l’origine est le nœud de choc.

Opérande NOM_CMP#

◊    NOM_CMP

Si OBSTACLE = “PLAN”, ou OBSTACLE = “BI_PLAN” alors ce mot-clé indique sur quel axe, “DX”, “DY” ou “DZ”, se trouve la butée.

Si OBSTACLE = “CERCLE”, alors ce mot-clé indique dans quel plan se trouve la butée.

Plan Oxy: (“DX”,”DY”),

Plan Oyz: (“DY”,”DZ”),

Plan Oxz: (“DX”,”DZ”)

Mot clé RESOLUTION#

♦ RESOLUTION


Sous ce mot-clé facteur, on renseigne le type d’algorithme et les paramètres associés. Les méthodes disponibles sont à déclarer sous l’opérande METHODE.

Opérande METHODE#

◊ METHODE

Choix de l’algorithme de calcul des modes non-linéaires. Le seul algorithme disponible actuellement est “EHMAN” correspondant à la combinaison de la méthode d’équilibrage harmonique (EH) et de la méthode asymptotique numérique (MAN), ainsi qu’un algorithme de Newton. Ce dernier permet de s’assurer de la convergence de l’algorithme.

Opérande NB_HARM_LINE#

♦ NB_HARM_LINE

Hl est le nombre d’harmoniques utilisé pour développer sous la forme d’une série de Fourier les variables de déplacements.

Opérande NB_HARM_NONL#

◊ NB_HARM_NONL

Hnl est le nombre d’harmoniques utilisé pour développer sous la forme d’une série de Fourier les fonctions représentatives des lois de comportement qui régissent la relation entre le nœud et la butée élastique. La condition suivante Hnl>Hl doit être respectée.

La valeur par défaut est 201.

Opérande NB_BRANCHE#

♦ NB_BRANCHE

nbraest le nombre de branches calculées par la MAN.

Opérande NB_PAS_MAN#

♦ NB_PAS_MAN

npasest le pas de discrétisation des branches calculées par la MAN.

Opérande NB_ORDRE_MAN#

◊ NB_ORDRE_MAN

nordreest le nombre de discrétisation des branches calculées par la MAN.

La valeur par défaut est 20.

Opérande PREC_MAN#

◊ PREC_MAN

eps_manest la tolérance de l’algorithme MAN.

La valeur par défaut est 1.E-9.

Opérande PREC_NEWTON#

◊ PREC_NEWTON

eps_newtest la tolérance de l’algorithme Newton.

La valeur par défaut est 1.E-8.

Opérande ITER_NEWTON_MAXI#

◊ PREC_NEWTON

iter_newtest le nombre d’itérations maximales de l’algorithme Newton.

La valeur par défaut est 15.

Opérande CRIT_ORDR_BIFURCATION#

◊ CRIT_ORDR_BIFURCATION

crit_bifest le nombre de coefficients de la série entière issue de la MAN. On effectue l’analyse de bifurcation sur ces points.

La valeur par défaut est 3.

Opérande RESI_RELA_BIFURCATION#

◊ RESI_RELA_BIFURCATION

eps_bifest la tolérance du critère qui permet de statuer sur la présence ou non d’une bifurcation.

La valeur par défaut est 1.E-4.

Mot clé SOLVEUR#

◊ SOLVEUR

La syntaxe de ce mot clé commun à plusieurs commandes est décrite dans le document [:external:ref:`U4.50.01 <U4.50.01>`].

Mot clé INFO#

◊ INFO

Entier permettant de préciser le niveau d'impression dans le fichier MESSAGE.

Si INFO=1, on signale uniquement le numéro de la branche calculée.

Si INFO=2, on affiche également l'erreur relative du dernier point de la branche. Ainsi que l'erreur pour chaque itération de Newton éventuelle. Et enfin, l'énergie et la fréquence du premier et du dernier point de la branche.