u4.52.01 Opérateur INFO_MODE

Syntaxe

Détail de la syntaxe

table = INFO_MODE(
    ◇ TYPE_MODE = / "MODE_COMPLEXE",
                  / "DYNAMIQUE" (par défaut),
                  / "MODE_FLAMB",
                  / "GENERAL",
    ◇ INFO = / 1 (par défaut),
             / 2,
    # Si: equal_to("TYPE_MODE", 'DYNAMIQUE')
        ◆ MATR_RIGI = matr_asse_pres_r / matr_asse_depl_c / matr_asse_depl_r / matr_asse_gene_c / matr_asse_gene_r / matr_asse_temp_r,
        ◆ MATR_MASS = matr_asse_pres_r / matr_asse_temp_r / matr_asse_gene_r / matr_asse_depl_r,
        ◆ FREQ = float,
        ⟐ COMPTAGE = _F(
             ◇ METHODE = / "AUTO" (par défaut),
                         / "STURM",
             ◇ SEUIL_FREQ = float (défaut: 0.01),
             ◇ PREC_SHIFT = float (défaut: 0.05),
             ◇ NMAX_ITER_SHIFT = int (défaut: 3),
          ),
    # Si: equal_to("TYPE_MODE", 'MODE_FLAMB')
        ◆ MATR_RIGI = matr_asse_pres_r / matr_asse_depl_c / matr_asse_depl_r / matr_asse_gene_c / matr_asse_gene_r / matr_asse_temp_r,
        ◆ MATR_RIGI_GEOM = matr_asse_pres_r / matr_asse_temp_r / matr_asse_gene_r / matr_asse_depl_r,
        ◆ CHAR_CRIT = float,
        ⟐ COMPTAGE = _F(
             ◇ METHODE = / "AUTO" (par défaut),
                         / "STURM",
             ◇ SEUIL_CHAR_CRIT = float (défaut: 0.01),
             ◇ PREC_SHIFT = float (défaut: 0.05),
             ◇ NMAX_ITER_SHIFT = int (défaut: 3),
          ),
    # Si: equal_to("TYPE_MODE", 'MODE_COMPLEXE')
        ◆ MATR_RIGI = matr_asse_pres_r / matr_asse_depl_c / matr_asse_depl_r / matr_asse_gene_c / matr_asse_gene_r / matr_asse_temp_r,
        ◆ MATR_MASS = matr_asse_pres_r / matr_asse_temp_r / matr_asse_gene_r / matr_asse_depl_r,
        ◇ MATR_AMOR = matr_asse_pres_r / matr_asse_temp_r / matr_asse_gene_r / matr_asse_depl_r,
        ◇ TYPE_CONTOUR = / "CERCLE" (par défaut),
                         / "CERCLE" (par défaut),
        ◆ RAYON_CONTOUR = float,
        ◇ CENTRE_CONTOUR = complex,
        ⟐ COMPTAGE = _F(
             ◇ METHODE = / "AUTO" (par défaut),
                         / "APM",
             ◇ NBPOINT_CONTOUR = int (défaut: 40),
             ◇ NMAX_ITER_CONTOUR = int (défaut: 3),
          ),
    # Si: equal_to("TYPE_MODE", 'GENERAL')
        ◆ MATR_A = matr_asse_pres_r / matr_asse_depl_c / matr_asse_depl_r / matr_asse_gene_c / matr_asse_gene_r / matr_asse_temp_r,
        ◆ MATR_B = matr_asse_pres_r / matr_asse_temp_r / matr_asse_gene_r / matr_asse_depl_r,
        ◇ MATR_C = matr_asse_pres_r / matr_asse_temp_r / matr_asse_gene_r / matr_asse_depl_r,
        ◇ CHAR_CRIT = float,
        # Si: not exists("CHAR_CRIT")
            ◇ TYPE_CONTOUR = / "CERCLE" (par défaut),
                             / "CERCLE" (par défaut),
            ◆ RAYON_CONTOUR = float,
            ◇ CENTRE_CONTOUR = complex,
        ⟐ COMPTAGE = _F(
             ◇ METHODE = / "AUTO" (par défaut),
                         / "STURM",
                         / "APM",
             ◇ SEUIL_CHAR_CRIT = float (défaut: 0.01),
             ◇ PREC_SHIFT = float (défaut: 0.05),
             ◇ NMAX_ITER_SHIFT = int (défaut: 3),
          ),
        ◇ NBPOINT_CONTOUR = int (défaut: 40),
        ◇ NMAX_ITER_CONTOUR = int (défaut: 3),
    ◇ TITRE = text,
    ⟐ SOLVEUR = _F(
         ◇ METHODE = / "MULT_FRONT",
                     / "LDLT",
                     / "MUMPS" (par défaut),
         # Si: equal_to("METHODE", 'MULT_FRONT')
             ◇ RENUM = / "MD",
                       / "MDA" (par défaut),
             ◇ NPREC = int (défaut: 8),
         # Si: equal_to("METHODE", 'LDLT')
             ◇ RENUM = "RCMK",
             ◇ NPREC = int (défaut: 8),
         # Si: equal_to("METHODE", 'MUMPS')
             ◇ RENUM = / "AMD",
                       / "AMF",
                       / "PORD",
                       / "METIS",
                       / "QAMD",
                       / "SCOTCH",
                       / "AUTO" (par défaut),
                       / "PARMETIS",
                       / "PTSCOTCH",
             ◇ NPREC = int (défaut: 8),
             ◇ ELIM_LAGR = / "NON",
                           / "LAGR2" (par défaut),
             ◇ TYPE_RESOL = / "NONSYM",
                            / "SYMGEN",
                            / "SYMDEF",
                            / "AUTO" (par défaut),
             ◇ ACCELERATION = / "AUTO",
                              / "FR" (par défaut),
                              / "FR+",
                              / "FR++",
                              / "LR",
                              / "LR+",
                              / "LR++",
             ◇ LOW_RANK_SEUIL = float,
             ◇ PRETRAITEMENTS = / "SANS",
                                / "AUTO" (par défaut),
             ◇ PCENT_PIVOT = int (défaut: 35),
             ◇ NB_RHS = int (défaut: 1),
             ◇ GESTION_MEMOIRE = / "IN_CORE",
                                 / "OUT_OF_CORE",
                                 / "AUTO" (par défaut),
                                 / "EVAL",
         # Si: equal_to("METHODE", 'GCPC')
             ◇ PRE_COND = / "LDLT_INC" (par défaut),
                          / "LDLT_SP",
                          / "LDLT_DP",
             ◇ RESI_RELA = float (défaut: 1e-06),
             ◇ NMAX_ITER = int,
             # Si: equal_to("PRE_COND", 'LDLT_INC')
                 ◇ RENUM = "RCMK",
                 ◇ NIVE_REMPLISSAGE = int,
             # Si: is_in("PRE_COND", ('LDLT_SP', 'LDLT_DP'))
                 ◇ RENUM = / "SANS",
                           / "METIS",
                           / "PARMETIS" (par défaut),
                 ◇ REAC_PRECOND = int (défaut: 30),
                 ◇ PCENT_PIVOT = int (défaut: 20),
                 ◇ GESTION_MEMOIRE = / "IN_CORE",
                                     / "AUTO" (par défaut),
                 ◇ LOW_RANK_SEUIL = float,
         # Si: equal_to("METHODE", 'PETSC')
             ◇ ALGORITHME = / "CG",
                            / "CR",
                            / "GMRES",
                            / "GCR",
                            / "FGMRES" (par défaut),
                            / "GMRES_LMP",
             ◇ OPTION_PETSC = text,
             ◇ PRE_COND = / "LDLT_INC",
                          / "LDLT_SP" (par défaut),
                          / "LDLT_DP",
                          / "JACOBI",
                          / "SOR",
                          / "ML",
                          / "BOOMER",
                          / "GAMG",
                          / "BLOC_LAGR",
                          / "FIELDSPLIT",
                          / "UTILISATEUR",
                          / "HPDDM",
                          / "SANS",
             ◇ RESI_RELA = float (défaut: 1e-06),
             ◇ NMAX_ITER = int,
             # Si: equal_to("PRE_COND", 'LDLT_INC')
                 ◇ RENUM = "RCMK",
                 ◇ NIVE_REMPLISSAGE = int,
                 ◇ REMPLISSAGE = float (défaut: 1.0),
             # Si: is_in("PRE_COND", ('LDLT_SP', 'LDLT_DP'))
                 ◇ RENUM = / "SANS",
                           / "METIS",
                           / "PARMETIS" (par défaut),
                 ◇ REAC_PRECOND = int (défaut: 30),
                 ◇ PCENT_PIVOT = int (défaut: 20),
                 ◇ GESTION_MEMOIRE = / "IN_CORE",
                                     / "AUTO" (par défaut),
                 ◇ LOW_RANK_SEUIL = float,
             # 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 = / "SANS" (par défaut),
                           / "RCMK",
      ),
    ◇ NIVEAU_PARALLELISME = / "PARTIEL",
                            / "COMPLET" (par défaut),
    ⟐ PARALLELISME_MACRO = _F(
      ),
)


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

Opérandes

Principes

Cette commande permet de compter le nombre de valeurs propres comprises dans (cf. figure 3ab):

• Un intervalle de l’axe réel (pour les problèmes généralisés GEPs standards à matrices réelles symétriques): mot-clé TYPE_MODE=”DYNAMIQUE’ou “MODE_FLAMB” ou “GENERAL”.

• Un disque du plan complexe (pour tous les autres cas de figure, autres GEPs et tous les problèmes quadratiques QEPs): mot-clé TYPE_MODE=”MODE_COMPLEXE” ou “GENERAL”.

Ce nombre de modes propres est tracé dans le fichier message pour chaque intervalle de l’axe réel ou pour la portion du plan complexe choisie (cf. figure 1). On rappelle aussi les caractéristiques de ces zones d’intérêt.

---

VERIFICATION DU SPECTRE DE FREQUENCES (METHODE DE STURM)

LE NOMBRE DE FREQUENCES DANS LA BANDE N 1 DE

BORNES ( 0.000E+00, 1.000E+01) EST 20

---

LE NOMBRE DE FREQUENCES DANS LA BANDE N 2 DE

BORNES ( 1.000E+01, 2.000E+01) EST 43

…..

LE NOMBRE DE FREQUENCES DANS LA BANDE N 6 DE

BORNES ( 5.000E+01, 6.000E+01) EST 139

---

Figure 1._ Affichages dans le fichier message d’un INFO_MODE sur une série de fréquences FREQ =(0.,10., 20., …,50., 60.) pour un problème de DYNAMIQUE.

Tous ces éléments sont stockés dans une sd_table (cf. figure 2ab) que l’on peut imprimer ( via un IMPR_TABLE) ou réutiliser (par des chaînages avec CALC_MODES). Le surcoût de cet opérateur peut alors devenir presque négligeable puisqu’on mutualise l’information globale dégagée avec d’autres opérateurs modaux.

#TABLE_SDASTER

FREQ_MIN FREQ_MAX BORNE_MIN_EFFECT BORNE_MAX_EFFECT NB_MODE

0.00000E+00 1.00000E-02 0.00000E+00 1.00000E-02 3

1.00000E-02 5.00000E-02 1.00000E-02 5.00000E-02 3

5.00000E-02 5.50000E-02 5.00000E-02 5.50000E-02 1

5.50000E-02 6.00000E-02 5.50000E-02 6.00000E-02 0

6.00000E-02 1.00000E-01 6.00000E-02 1.00000E-01 3

#TABLE_SDASTER

CHAR_CRIT_MIN CHAR_CRIT_MAX BORNE_MIN_EFFECT BORNE_MAX_EFFECT NB_MODE

-1.00000E+06 -5.00000E+05 -1.00000E+06 -5.00000E+05 1

-5.00000E+05 0.00000E+00 -5.00000E+05 0.00000E+00 3

0.00000E+00 1.00000E+05 0.00000E+00 1.00000E+05 0

1.00000E+05 1.10000E+06 1.00000E+05 1.10000E+06 5

Figure 2ab._ Exemple n°1 de table générée par un INFO_MODE sur une série de fréquences FREQ =(0.,1.E-2,…,1.E-1) pour un problème de dynamique *. Extrait de sdlx201a.mess. Exemple n°2 de table générée par un* INFO_MODE sur une série de charges critiques CHAR_CRIT =(-1.E+6,-5.E+5,…,1.1E+6) pour un problème de flambement . Extrait de sdls504a.mess

L’appel à cet opérateur est préconisé comme vérification/calibration a priori du modèle. Il permet aussi de définir des intervalles de recherche contenant un nombre raisonnable de valeurs propres (typiquement une quarantaine de modes) afin d’optimiser les coûts des opérateurs modaux ultérieurs et de ne pas dégrader la précision de leurs résultats.

Typiquement, on conseille de rechercher les modes par paquets de quarante environ [3] . Au delà, les consommations en temps et en mémoire ne sont plus optimales et la qualité des modes obtenus se dégrade. Il vaut alors mieux utiliser plusieurs bandes de fréquences (ou de charges critiques) directement avec CALC_MODES et l’option “BANDE” découpée sur plusieurs sous-bandes, ou par plusieurs appels à CALC_MODES [U4.52.02].

Idéalement, pour traiter efficacement un GEP standard , on propose de procéder en plusieurs étapes:

• Calibrer les zones d’intérêt par des pré-calculs utilisant uniquement INFO_MODE(en séquentiel ou, si possible, en parallèle) sur des listes de fréquences (resp. charges critiques) données;

• Relancer un ou plusieurs calculs CALC_MODES avec OPTION=”BANDE” en se basant sur ces calibrations initiales.

Pour gagner du temps, on peut même mutualiser (et c’est fortement conseillé !) une partie du coût calcul de l’INFO_MODE initial en notifiant à CALC_MODES le nom de la sd_tablegénérée. Ce chaînage peut ainsi rendre le surcoût d’INFO_MODE négligeable et guider efficacement le calcul modal.

Coté calcul intensif, l’opérateur INFO_MODE, tout comme CALC_MODES avec l’option “BANDE” découpée en plusieurs sous-bandes, bénéficie potentiellement de deux niveaux de parallélisme (cf. mot-clé NIVEAU_PARALLELISME). D’où des gains en temps d’un facteur jusqu’à 70 sur une centaine de processeurs et des gains en pic mémoire jusqu’à un facteur 2.

Figure 3ab._ Deux problématiques de dénombrement distinctes: dans un segment de l’axe réel et dans une portion finie du plan complexe (pour l’instant qu’un disque).

Dans le premier cas, lorsqu’on cherche à dénombrer les valeurs propres strictement incluses dans un segment de l’axe réel, on utilise la méthode dite de «Sturm», dans le second cas la méthode APM. Leurs théories et algorithmies sont détaillées dans la documentation de référence [R5.01.04].

Lorsqu’on traite des GEPs standards, l’exécution de cette procédure ne nécessite généralement [4] qu’une factorisation LDLT par mode (METHODE=”STURM”). Lorsqu’elles sont disséminées dans le plan complexe, la procédure est beaucoup plus coûteuse (METHODE=”APM”) car elle requiert, en général, des centaines de factorisations. Dans ce cas de figure, elle est donc plutôt à réserver aux problèmes simplifiés de petites tailles (inférieurs à 1000 degrés de liberté).

Notons que cette dernière méthode APM est encore l’objet de recherches actives. Sa robustesse n’est donc, pour l’instant, pas garantie. Elle est à utiliser en ayant bien pris soin de lire la documentation associée.

Caractéristiques du problème modal: opérandes MATR_RIGI/ MATR_A/MATR_MASS/MATR_RIGI_GEOM/MATR_B/MATR_AMOR/ MATR_C

Le tableau ci-dessous représente les opérandes à utiliser en fonction type du mot-clé TYPE_MODE.

TYPE_MODE
“DYNAMIQUE”	“MODE_FLAMB”	“MODE_COMPLEXE”	“GENERAL”
♦ MATR_RIGI = A	♦ MATR_RIGI = A	♦ MATR_RIGI = A	♦ MATR_A = A
♦ MATR_MASS = B	♦ MATR_RIGI_GEOM = B	♦ MATR_MASS = B	♦ MATR_B = B
Sans Objet	Sans Objet	◊ MATR_AMOR = C	◊ MATR_C = C

Ces opérandes permettent de renseigner les matrices (assemblées ou généralisées [5] ) caractérisant le problème modal. Ces matrices peuvent être symétriques ou non. Elles sont réelles sauf la matrice \(\mathrm{A}\) qui peut être, soit réelle, soit complexe.

La donnée de \(\mathrm{A}\) et \(\mathrm{B}\) permet de définir le problème modal généralisé (GEP) (cf. [R5.01.01]) étudié

\(\mathrm{A}\mathrm{u}=\lambda \mathrm{B}\mathrm{u}({\mathrm{GEP}}_{\mathrm{dynamique}})\)

Dans le cas classique de la dynamique (TYPE_MODE=”DYNAMIQUE”), \(\mathrm{A}\) est la matrice de rigidité (symétrique réelle) et \(\mathrm{B}\) et la matrice de masse (symétrique réelle). La valeur propre \(\lambda\) est alors reliée à la fréquence propre \(f\) par la formule: \(\lambda ={(2\pi f)}^{2}\) . Elle est réelle positive.

Dans le cas de la théorie du flambement linéaire (TYPE_MODE=”MODE_FLAMB”),

\(\mathrm{A}\mathrm{u}-\lambda \mathrm{B}\mathrm{u}=0({\mathrm{GEP}}_{\mathrm{flambement}})\)

\(\mathrm{A}\) est la matrice de rigidité (symétrique réelle) et \(\mathrm{B}\) la matrice de rigidité géométrique (symétrique réelle). La valeur propre \(\lambda\) est appelée charge critique. Elle est réelle.

Comme mentionné dans le tableau précédent, ces matrices seront renseignées, respectivement, pour la dynamique par MATR_RIGI/MATR_MASS et, en flambement, par MATR_RIGI/ MATR_RIGI_GEOM. Seule la méthode dite de “STURM” est licite dans ces deux cas de figure.

Lorsqu’une des deux matrices n’est plus symétrique ou comporte des termes complexes (par ex. pour prendre en compte de l’amortissement hystérétique), les valeurs propres sont potentiellement complexes. Pour traiter ce problème il faut initialiser TYPE_MODE à “MODE_COMPLEXE” et seule la méthode APM est alors licite.

La donnée de \(\mathrm{A}\) , \(\mathrm{B}\) et \(\mathrm{C}\) permet de définir le problème modal quadratique (QEP) (cf. [R5.01.02]) étudié

\((\mathrm{A}+\lambda \mathrm{C}+{\lambda}^{2}\mathrm{B})\mathrm{u}=0(\mathrm{QEP})\)

Dans ce cas de figure, les valeurs propres sont potentiellement complexes. Pour traiter ce problème il faut initialiser TYPE_MODE à “MODE_COMPLEXE”. Souvent \(\mathrm{A}\) est la matrice de rigidité, \(\mathrm{C}\) une matrice prenant en compte l’amortissement visqueux et/ou des effets gyroscopiques et \(\mathrm{B}\) la matrice de rigidité géométrique. Comme mentionné dans le tableau précédent, ces matrices seront renseignées par MATR_RIGI/MATR_MASS/MATR_AMOR et seule la méthode APM est licite.

Le TYPE_MODE=”GENERAL” permet de résoudre un problème de valeurs propres dans le cas générale. On fait alors jouer aux matrices \(\mathrm{A}\) , \(\mathrm{B}\) et/ou \(\mathrm{C}\) le rôle que l’on souhaite. Comme mentionné dans le tableau précédent, ces matrices seront renseignées par MATR_A/MATR_B/MATR_C. Suivant les cas de figure, seule la méthode de Sturm (si MATR_C n’est pas renseignée et si les deux autres matrices sont réelles symétriques) ou la méthode APM (tous les autres cas) sont licites.

Opérande TYPE_MODE

◊ TYPE_MODE= / ‘DYNAMIQUE’ [DEFAUT] / ‘MODE_FLAMB’ / “MODE_COMPLEXE” / “GENERAL”

Ce mot-clé permet de définir la nature du problème modal à traiter: pré-estimer le spectre de fréquences de vibration (cas classique de “DYNAMIQUE”), le faire en terme de de charges critiques (cas de la théorie du flambement linéaire “MODE_FLAMB”) ou calibrer celui d’un GEP non standard ou d’un QEP dans une portion du plan complexe (“MODE_COMPLEXE”). On peut aussi rechercher les valeurs propres et les modes associés d’un système matriciel général (“GENERAL”). Pour plus de précisions on pourra se reporter au descriptif du §3.2.

A l’issu de ce choix, l’utilisateur doit spécifier les caractéristiques de sa zone de contrôle:

• pour “DYNAMIQUE”: liste de fréquences via FREQ,

• pour “MODE_FLAMB”: liste de charges critiques via CHAR_CRIT,

• pour “MODE_COMPLEXE”: zone du plan complexe via TYPE/RAYON/CENTRE_CONTOUR,

• pour “GENERAL”: suivant le cas de figure, soit on procède comme pour “MODE_FLAMB” (si MATR_Cn’est pas renseignée et si les deux autres matrices sont réelles symétriques), soit comme pour “MODE_COMPLEXE” (tous les autres cas).

Opérande FREQ

♦ FREQ = l_f

Liste de fréquences (en Hertz) définissant les intervalles que l’on veut calibrer \(\text{l\_f}={({f}_{i})}_{i}\) (on note nb_freq le nombre de fréquences de cette liste). On recherche alors le nombre de valeurs propres dans les sous-bandes \([{\lambda}_{i},{\lambda}_{\text{i+1}}]\) avec \({\lambda}_{\text{*}}={(2\pi {f}_{\text{*}})}^{2}\) .Cette liste doit comporter au moins deux valeurs. Ces valeurs doivent être rangées par ordre strictement croissant et toutes positives.

Ce mot-clé doit être utilisé si TYPE_MODE=‘DYNAMIQUE’. Seule la méthode de comptage de type STURM est alors licite.

Remarques:

• Chaque fréquence n’est traitée qu’une seule fois: en tant que borne inférieure de la première sous-bande pour la première de la liste, en tant que borne supérieure des sous-bandes qui suivent pour les autres fréquences. En particulier, si cette fréquence est jugée trop proche d’une valeur propre, on la décale (éventuellement plusieurs fois cf. paramètres PREC_SHIFT/NMAX_ITER_SHIFT etc). Ce décalage «du shift» est toujours opérée vers l’extérieure de la sous-bande considérée.

• Si le décalage de la borne inférieure la rend plus grande que la borne supérieure, le processus s’arrête en ERREUR_FATALE .

• Ce mode de décalage rend plus robuste et consistant les réutilisations ultérieures de cette sd_table par un ou plusieurs CALC_MODES . On évite en particulier les recouvrements de sous-bandes qui pouvaient se produire jusqu’à la V10.

• Les bornes initiales de chacune de ces sous-bandes sont sauvegardées dans les champs FREQ_MIN/MAX de chaque ligne de la table produite (cf. figure 2a). Pour chacun de ces couples, on mentionne les bornes effectivement utilisées par le test de Sturm (c’est-à-dire après d’éventuels décalages), BORNE_MIN/MAX_EFFECT , ainsi que le nombre de modes trouvés: NB_MODE .

Opérandes CHAR_CRIT

CHAR_CRIT = l_c

Liste de charges critiques définissant les intervalles que l’on veut calibrer \(\text{l\_c}={({\lambda}_{i})}_{i}\) (on note nb_mode_flamb le nombre de charges critiques de cette liste). On recherche alors le nombre de valeurs propres dans les sous-bandes \([{\lambda}_{i},{\lambda}_{\text{i+1}}]\) .Cette liste doit comporter au moins deux valeurs. Ces valeurs doivent être rangées par ordre strictement croissant. Elles doivent être de type réel.

Ce mot-clé doit être utilisé si TYPE_MODE=‘MODE_FLAMB’ou si TYPE_MODE=‘GENERAL’ (si MATR_Cn’est pas renseignée et si les deux autres matrices sont réelles symétriques). Seule la méthode de comptage de type STURMest licite.

Remarques:

• Chaque charge critique n’est traitée qu’une seule fois: en tant que borne inférieure de la première sous-bande pour la première de la liste, en tant que borne supérieure des sous-bandes qui suivent pour les autres fréquences. En particulier, si cette charge est jugée trop proche d’une valeur propre, on la décale (éventuellement plusieurs fois cf. paramètres PREC_SHIFT/NMAX_ITER_SHIFT etc). Ce décalage «du shift» est toujours opérée vers l’extérieure de la sous-bande considérée.

• Si le décalage de la borne inférieure la rend plus grande que la borne supérieure, le processus s’arrête en ERREUR_FATALE .

• Ce mode de décalage rend plus robuste et consistant les réutilisations ultérieures de la sd_table par un ou plusieurs CALC_MODES . On évite en particulier les recouvrements de sous-bandes qui pouvaient se produire jusqu’à la V10.

• Les bornes initiales de chacune de ces sous-bandes sont sauvegardées dans les champs CHAR_CRIT_MIN/MAX de chaque ligne de la table produite (cf. figure 2b). Pour chacun de ces couples, on mentionne les bornes effectivement utilisées par le test de Sturm (c’est-à-dire après d’éventuels décalages), BORNE_MIN/MAX_EFFECT , ainsi que le nombre de modes trouvés: NB_MODE .

Opérandes TYPE/RAYON/CENTRE_CONTOUR

Si TYPE_MODE=‘MODE_COMPLEXE’ ou si TYPE_MODE=‘GENERAL’ (si MATR_C est renseignée ou/et si une des matrices est non symétrique ou complexe)

◊ TYPE_CONTOUR = “CERCLE” [DEFAUT] ♦ RAYON_CONTOUR = rayon [R] ◊ CENTRE_CONTOUR = / centre [C] / 0.0+0.0j [DEFAUT]

Ces mots-clés définissent le type de contour à l’intérieur duquel on cherche les valeurs propres ainsi que ses caractéristiques. Pour l’instant on ne peut choisir qu’un contour de type “CERCLE” (qui délimite donc le disque de contrôle). On mentionne son centre(un nombre complexe) et son rayon(un réel positif).

Remarques:

• En toute rigueur, ce rayon doit être supérieur au «zéro modal». C’est-à-dire supérieur à la valeur en dessous de laquelle on considère qu’une valeur propre est nulle ou que deux valeurs propres sont confondues si on parle de leur écart.

• Contrairement aux valeurs de FREQ, les unités ne sont pas ici en fréquence, mais en pulsation si on fait l’analogie avec le problème DYNAMIQUE. Comme pour un TYPE_MODE=”MODE_FLAMB”, l’unité des caractéristiques du contour ne subit aucune transformation. Cela permet à la méthode APM de traiter tous les types de problèmes.

• La table produite avec l’option TYPE_MODE=”MODE_COMPLEXE” contient, en plus du nombre de valeurs propres ( NB_MODE ), trois réelles permettant de décrire les critères de recherche pour la méthode APM. Les deux premiers sont CENTRE_R etCENTRE_I, les parties réelle et imaginaire du nombre complexe qui correspond au centre du disque de recherche. Le troisième paramètre, RAYON, est le rayon (réel strictement positif>1.D-2) du disque.

Mot-clé facteur COMPTAGE

Une fois défini le type de zone de contrôle (segment ou disque), il reste à fixer la méthode de dénombrement et ses paramètres.

◊ METHODE = / ‘AUTO’, [DEFAUT] / ‘STURM’, / “APM”.

Si on traite un problème de type “DYNAMIQUE” ou “MODE_FLAMB”, seule les méthodes “STURM” et “AUTO” sont autorisées.

De même pour “MODE_COMPLEXE” et “APM”/”AUTO”.

Dans le cas “GENERAL”, les trois méthodes sont disponibles et la valeur “AUTO” prend alors tout son sens ! Elle choisit pour l’utilisateur entre STURM et APM suivant les caractéristiques du problème modal:

• Soit il s’agit d’un GEP standard (deux matrices symétriques réelles): méthode de STURM.

• Dans tous les autres cas (GEP atypique avec matrice non symétrique et/ou complexe ou QEP): méthode APM.

Si on laisse le mode 'AUTO' paramétré par défaut, l'opérateur choisit automatiquement la méthode suivant le type d'étude choisie. On a laissé sciemment cette valeur, même dans les cas qui ne comportent qu'une seule alternative, pour faciliter l'ergonomie.


Si on se trompe de METHODE, une alarme apparaît et l'opérateur choisit automatiquement la méthode la plus appropriée ou s'arrête en ERREUR_FATALE, suivant les cas de figure.

Remarque:

• On peut utiliser la méthode APMpour dénombrer les modes d’un GEP standard en posant TYPE_MODE=”MODE_COMPLEXE”. Cela permet de comparer et valider les deux méthodes de comptage (cf. cas-test SDLL123a).

# Si TYPE_MODE=‘DYNAMIQUE’

◊ SEUIL_FREQ = / f_seuil [R] / 0.01 [DEFAUT] ◊ PREC_SHIFT = / p_shift [R] / 0.05 [DEFAUT] ◊ NMAX_ITER_SHIFT = / n_shift [I] / 3 [DEFAUT]

# Si TYPE_MODE=‘MODE_FLAMB’ ou “GENERAL” (si MATR_C n’est pas renseignée et si les deux autres matrices sont symétriques réelles)

◊ SEUIL_CHAR_CRIT = / c_seuil [R] / 0.01 [DEFAUT] ◊ PREC_SHIFT = / p_shift [R] / 0.05 [DEFAUT] ◊ NMAX_ITER_SHIFT = / n_shift [I] / 3 [DEFAUT]

Ces paramètres ne sont utilisés que par la méthode de STURM.

Les paramètres SEUIL_* permettent de définir le «zéro modal», c’est-à-dire la valeur en deçà de laquelle on considère que la valeur propre est nulle. Si on est en dynamique on transforme cette valeur en pulsation

\(\mathit{omecor}={(2\pi \text{f\_seuil})}^{2}\)

tandis qu’en flambement on la garde telle quelle

\(\mathit{omecor}=\text{c\_seuil}\).

Les autres paramètres, PREC_SHIFT et NMAX_ITER_SHIFT, sont liés à l’algorithme de décalage des bornes de l’intervalle (cf. [R5.01.04] §3.2) lorsqu’on s’aperçoit que celles-ci sont très proches d’une valeur propre. Grossièrement ces bornes \({f}_{\min}`(ou :math:`{\lambda}_{\min}`en flambement) ou :math:`{f}_{\max}`(resp. :math:`{\lambda}_{max}\)) sont alors décalées vers l’extérieur du segment de p_shift%. Si la matrice dynamique ainsi reconstruite est toujours jugée “numériquement singulière”, on re-décale à nouveau après avoir émis une ALARME. On tente ce décalage n_shift fois.

:math:`{{lambda}^{-}}_{min}={lambda}_{min}-max(mathit{omecor}{,2}^{(i-1)}text{x}{p}_{mathit{shift}}text{x}∣({lambda}_{min})∣)`(ième tentative)

:math:`{{lambda}^{-}}_{max}={lambda}_{max}+max(mathit{omecor}{,2}^{(i-1)}text{x}{p}_{mathit{shift}}text{x}∣({lambda}_{max})∣)`(ième tentative)

En fait, en dynamique comme en flambement le décalage s’opère de la même manière. Stricto-censu, en dynamique ce n’est donc pas les fréquences qu’on décale, mais les pulsations.

Autre précision, le décalage est en fait, par soucis d’efficacité, dichotomique: p_shift% la première fois, 2xp_shift% la seconde fois etc. Ce procédé doit permettre de rapidement s’éloigner de la “zone de singularité” à moindre coût. A contrario, il ne faut pas trop augmenter les valeurs de ces paramètres, car à force de décalages, les bornes résultantes peuvent s’avérer être très différentes des bornes initiales.

De plus, pour rester cohérent avec le “zéro modal” (noté ici omecor):

• On ne décale pas d’une valeur inférieure à ce minimum (d’où le max dans les formules ci-dessus),

• Si dés le départ, la borne jaugée est inférieure à ce “zéro” \(∣{\lambda}_{\text{*}}∣<\mathit{omecor}\) (en valeur absolue) on la fixe à plus ou moins cette valeur (suivant que cette borne soit positive ou négative). On ne permet alors plus aucun décalage.

Remarques:

• Une borne de l’intervalle \(\sigma\) est proche d’une valeur propre, lorsque la factorisation LDLT de la matrice dynamique associée à cette borne (par exemple celle d’un GEP s’écrit \(\mathrm{Q}(\sigma ):=\mathrm{A}-\sigma \mathrm{B}\) ), conduit à une perte de décimale de plus de NPRECdigits (valeur paramétrée sous le mot-clé SOLVEUR).En jouant sur la valeur de ce paramètre (NPREC=7, 8 ou 9), on peut alors éviter les coûteuses refactorisations qu’impliquent ces décalages lorsque cette singularité numérique est peu prononcée.

• De même, en jouant sur les paramètres numériques des solveurs linéaires (par exemple: METHODE, RENUM, PRETRAITEMENTS …), on peut aussi influencer ce critère de singularité.

# Si TYPE_MODE=‘MODE_COMPLEXE’ ou 'GENERAL' (si MATR_C est renseignée ou/et si une des deux autres matrices est non symétrique ou complexe)

◊ NBPOINT_CONTOUR = / nb_point [I] / 40 [DEFAUT] ◊ NMAX_ITER_CONTOUR = / n_contour [I] / 3 [DEFAUT]

Ces paramètres ne sont utilisés que par la méthode APM.

Les deux paramètres précédent, NB_POINT_CONTOUR et NMAX_ITER_CONTOUR, ne sont utilisés qu'avec la méthode APM. Ils sont cruciaux pour sa robustesse et ils dimensionnent son temps calcul (un calcul avec nb_point=80 durera plus longtemps qu'un calcul avec nb_point=40).

La valeur nb_point donne le nombre de point de discrétisation qui sont positionnés le long du contour. Cette discrétisation doit être assez fine pour «capturer» toute l'information spectrale. Idéalement, cette valeur doit être fixée à au moins six fois le nombre de modes que l'on escompte trouver dans la cercle. Si on n'a aucune idée a priori de ce nombre, il faut le fixer à une valeur pas trop faible: par exemple, 40 ou 60.

Remarque:

• Attention, si ce chiffre est trop grand (par exemple 1000), suivant la taille du problème, comme il implique autant de factorisations LDLT, le calcul peut être très long !

L'algorithme APM implanté ne convergera que lorsque 3 évaluations successives du nombre de valeurs propres fourniront le même résultat. La différences entre ces trois évaluations réside uniquement dans le degré de discrétisation du contour. On commence par discrétiser avec :math:`{k}_{-}=\text{nb\_point}/2`, puis avec :math:`k=\text{nb\_point}`et enfin avec :math:`{k}_{+}=2\text{nb\_point}`. Si ces trois niveaux de discrétisation du contour produisent une estimation du nombre de valeurs propres identiques, l'algorithme est considéré comme convergé. Son résultat est alors ce nombre entier.

Sinon, on double ces trois niveaux de discrétisations suivant la permutation suivante

:math:`{k}_{-}\leftarrow k`, :math:`k\leftarrow {k}_{+}`et :math:`{k}_{+}\leftarrow 2{k}_{+}`

[6] . Si ils sont identiques, la convergence est atteinte, sinon on continue. On réitère cette heuristique dichotomique au maximum n_contour fois.

Si ce processus n'a pas convergé ou si son résultat est incohérent (entier strictement négatif), on s'arrête en ERREUR_FATALE.

Opérande INFO

◊ INFO = / 1 [DEFAUT] / 2

Indique le niveau d’impression dans le fichier MESSAGE.

1: Impression du résultat (et des étapes principales de l’algorithme si APM).

2: Impression plus détaillée plutôt pour développeur.

Opérande TITRE

Le titre qui sera donné à la table produite.

Mot-clé facteurSOLVEUR

◊    SOLVEUR=_F(),


On a accès à tous les paramètres des solveurs linéaires directs (METHODE='LDLT'/'MULT_FRONT'/'MUMPS') sauf ceux explicitement liés à l'étape finale de descente-remontée. Cette restriction ne concernent que les deux paramètres suivant du solveur MUMPS: POSTTRAITEMENTS et RESI_RELA.

En parallèle, on conseille particulièrement le paramétrage [7] METHODE=”MUMPS’et RENUM=”QAMD”.

Pour plus de détails sur les solveurs, on pourra consulter le document [:ref:`U4.50.01 <U4.50.01>`].

Opérande NIVEAU_PARALLELISME

◊    NIVEAU_PARALLELISME =    /    'COMPLET'            [DEFAUT]

/ “PARTIEL”

Lorsqu’on traite des problèmes de tailles moyennes ou grandes (> 0.5M degrés de liberté) et/ou que l’on cherche une bonne partie de leurs spectres (> 50 modes), le recours au parallélisme procure des gains appréciables en temps et en mémoire. Et ce, avec un comportement fonctionnel et des précisions de résultats inchangés par rapport au mode séquentiel.

Le découpage naturel du calcul INFO_MODE en nb_sbande indépendantes (nombre de sous-bandes=nb_freq-1 ou nb_mode_flamb-1), procure un premier niveau de parallélisme très efficace (en temps). Il n’impacte pas les consommations mémoire [8] .

D’autre part, comme l’essentiel du coût calcul est dû à la phase de factorisation numérique [9] du solveur linéaire, si on parallélise cette étape via MUMPS (METHODE=”MUMPS”), on rajoute des gains notables en temps et en mémoire. C’est un deuxième niveau de parallélisme activable.

Avec la valeur par défaut de ce mot-clé (NIVEAU_PARALLELISME=”COMPLET”), lorsque le calcul est parallèle, les deux niveaux de parallélisme se cumulent. Comme le second (celui du solveur linéaire) est moins efficace que le premier, il ne se déclenche que si le nombre de processeurs le permet (nb_proc>nb_sbande) et que si le solveur linéaire sélectionné supporte du parallélisme MPI (SOLVEUR=_F(METHODE=”MUMPS”)).

Si on sélectionne l’autre valeur du mot-clé (NIVEAU_PARALLELISME=”PARTIEL”), on ne profite que du parallélisme du solveur linéaire (le second niveau). Cela peut avoir de l’intérêt pour tester des méthodes ou pour axer les gains sur la réduction du pic mémoire (après avoir essayé les autres bras de levier proposés dans le mot-clé SOLVEUR).

Pour plus d’informations sur la mise en œuvre du parallélisme, on se reportera à la documentation [U2.08.06] ou au paragraphe dédié de la documentation [U2.06.01].

Figure 3.11-1. Exemple de distribution des calculs d “INFO_MODE sur 8 processeurs avec un découpage en 4 sous-bandes fréquentielles.

Ainsi, en activant seulement le premier niveau de parallélisme, un calcul découpé en nb_sbande et parallélisé sur nb_proc=nb_sbande peut gagner en temps au moins un facteur nb_sbande/2 (sans surcoût mémoire et sans perte de précision).

Si on distribue le calcul sur plus de processeurs (nb_proc>nb_sbande) en utilisant le solveur MUMPS (en ajoute ainsi le 2nd niveau), les gains en temps vont être améliorés d’un facteur proche de 2 pour chaque 2* nb_sbande processeurs supplémentaires [10]_ . Et ce, avec des gains en mémoire pouvant aller jusqu’à un facteur 2 [11]_ .

Afin de préserver l’efficacité des calculs parallèle, on conseille:

• Avec “COMPLET”, de sélectionner un nombre de processeurs qui est un multiple du nombre de sous-bandes. Typiquement 2, 4 ou 8. Cela limite les déséquilibre de charge.

• Avec “PARTIEL”, de réserver au moins 105 degrés de liberté par processeur afin d’alimenter suffisamment le solveur linéaire MUMPS.

Les règles fonctionnelles sont les suivantes, en notant nb_proc le nombre de processeurs paramétré (onglet option/mpi_nbcpu d’Astk) et nb_sbande le nombre de sous-bandes non vides:

• Avec NIVEAU_PARALLELISME=”COMPLET”(défaut) : très gros gain en temps/amélioration du pic mémoire RAM.

Figure 3.11-2. Périmètre d’utilisation avec NIVEAU_PARALLELISME=”COMPLET”.

• Avec NIVEAU_PARALLELISME=”PARTIEL”: gain modéré en temps/gain important sur le pic mémoire RAM.

nb_proc

Figure 3.11-3. Périmètre d’utilisation avec NIVEAU_PARALLELISME=”PARTIEL”.

[1]

En mode séquentiel. Avec CALC_MODES option “BANDE” découpée sur plusieurs sous-bandes parallèle, on peut obtenir un calcul plus rapidement en ne prenant qu’une vingtaine de modes.

[2]

Sauf si la valeur est proche d’un mode propre, auquel cas on la «décale» (cf. mot-clé NMAX_ITER_SHIFT) pour limiter certaines instabilités numériques.

[3]

Cette notion de matrice généralisée n’a rien à voir avec celle de problème modal généralisé !

[4]

Bien sûr pour économiser du temps calcul, on ne réévalue que pour la nouvelle discrétisation, la plus fine.

[5]

Afin de réduire au minimum le coût en temps de la phase d’analyse (séquentielle) de MUMPS. Ce paramétrage se fait cependant au détriment de la consommation mémoire. Mais ce surcoût s’avère rapidement compensé par la distribution des données sur les processeurs qu’implique le parallélisme.

[6]

Ce qui est le cas pour CALC_MODES avec OPTION=”BANDE” découpée sur plusieurs sous-bandes parallélisées.

[7]

Etape du solveur linéaire qui tire le plus de profit du parallélisme.

[8]

Sur des problèmes suffisamment gros (N>0.5M), l’efficacité parallèle de la phase de factorisation de MUMPS est souvent proche de 0.5 (surtout avec un renuméroteur frustre type “QAMD” cf. §3.10).

[9]

Dans INFO_MODE, les consommations mémoire de MUMPS sont particulièrement optimisées: le fonctionnement en IN-CORE ne consomme pas plus de mémoire que l’OUT-OF-CORE (gain x3). Ce comportement est adapté pour cet opérateur. Les gains que peuvent lui procurer le parallélisme sont donc, en proportion, moins importants.

Exemples

Exemple n°1

Comparaison des deux méthodes STURMet APMsur le GEP standard de SDLD02a (pour STURMles bornes sont mentionnées en fréquence). Dans le premier calcul, on chercher à compter le nombre de modes contenu dans la bande fréquentielle \([0;5]\) avec la méthode usuelle: STURM. Dans le second, on fait la même chose avec la méthode APM, mais dans le disque centré à l’origine (centre=0+0j)et de rayon rayon= \({(2\pi .5)}^{2}\) (car il n’y a pas de changement d’unité avec APM). Les deux résultats sont affichés dans le fichier MESSAGE.

f1=5.0

nbmod01 = INFO_MODE (MATR_RIGI=MATASSR,MATR_MASS=MATASSM,TYPE_MODE=” DYNAMIQUE “,

FREQ=(0.,f1),COMPTAGE=_F(METHODE=” STURM “),)

w1=(2*pi*f1)**2

nbmod11 = INFO_MODE (MATR_RIGI=MATASSR,MATR_MASS=MATASSM,TYPE_MODE=” MODE_COMPLEXE “,

TYPE_CONTOUR=”CERCLE”,CENTRE_CONTOUR=0.0+0.0j,

RAYON_CONTOUR=w1,COMPTAGE=_F(METHODE=” APM “),)

Avec INFO=1, cela provoque les affichages suivant dans le fichier MESSAGE:

---

VERIFICATION DU SPECTRE DE FREQUENCES ( METHODE DE STURM )

PAS DE FREQUENCE DANS LA BANDE ( 0.000E+00, 5.000E+00)

………………

(METHODE APM) POUR LES 3 NIVEAUX DE DISCRETISATION SUIVANTS

— 20 — 40 — 80 —

NOMBRE DE VALEURS PROPRES DETECTEES

— 0 — 0 — 0 —

(METHODE APM) CONVERGENCE DE L’HEURISTIQUE

---

VERIFICATION DU SPECTRE EN FREQUENCE ( METHODE DE L’ARGUMENT PRINCIPAL )

PAS DE FREQUENCE DANS LE DISQUE CENTRE EN ( 0.000E+00, 0.000E+00)

ET DE RAYON 9.870E+02

Ici, la méthode de Sturm a requis seulement deux factorisations. La méthode APM a convergé immédiatement à la première itération. Mais celle-ci a nécessité \(20+40+80=140\) factorisations. Le dénombrement de valeurs propres dans le plan complexe a un prix (que l’on arrive pas pour l’instant à réduire) !

Lenombre des fréquences propres (0 dans ce cas) ainsi que les critères de recherche sont sauvegardés dans unetable. L’impression, par IMPR_TABLE, des concepts NBMOD01et NBMOD11produits par INFO_MODE dans l’exemple précédent montre la composition suivante :

nbmod01

FREQ_MIN FREQ_MAX NB_MODE

0.00000E+00 5.00000E+00 0

…

nbmod11

CENTRE_R CENTRE_I RAYON NB_MODE

0.00000E+00 0.00000E+00 9.86960E+02 0

Quand INFO_MODE est appelé avec l’option TYPE_MODE=”MODE_FLAMB”, les tables produites contiennent trois colonnes: NB_MODE (le nombre de valeurs propres) ainsi que CHAR_CRIT_MIN et CHAR_CRIT_MAX, les critères de recherche pour les problèmes dynamiques avec flambement linéaire.

Exemple n°2

Dénombrement concernant le QEP de SDLL123a. Cette fois, seule la méthode APM s’avère licite. On compte le nombre de modes contenus dans le cercle centré à l’origine (\(\mathit{centre}=0+\mathrm{0j}\) ) et de rayon \(\mathit{rayon}=124\times 2\pi\) .

f1=124.*2.*pi

nbmod4= INFO_MODE (MATR_RIGI=RIGIDITE,MATR_MASS=MASSE,MATR_C=GYOM,TYPE_MODE=” MODE_COMPLEXE “,

TYPE_CONTOUR=”CERCLE”,CENTRE_CONTOUR=0.0+0.0j,

RAYON_CONTOUR=f1, COMPTAGE=_F(METHODE=” APM “,),)

En INFO=1 cela provoque les affichages suivant dans le fichier MESSAGE:

(METHODE APM) POUR LES 3 NIVEAUX DE DISCRETISATION SUIVANTS

— 20 — 40 — 80 —

NOMBRE DE VALEURS PROPRES DETECTEES

— 4 — 4 — 4 —

(METHODE APM) CONVERGENCE DE L’HEURISTIQUE

---

VERIFICATION DU SPECTRE EN FREQUENCE ( METHODE DE L’ARGUMENT PRINCIPAL )

LE NOMBRE DE FREQUENCES DANS LE DISQUE CENTRE EN ( 0.000E+00, 0.000E+00)

ET DE RAYON 7.791E+02 EST 4

Et l’impression de la table produite (nbmod4) par IMPR_TABLE donne:

CENTRE_R CENTRE_I RAYON NB_MODE

0.00000E+00 0.00000E+00 7.79115E+02 4