u4.65.11 Opérateur CREA_ELEM_SSD#

Syntaxe#

Détail de la syntaxe
/ macr_elem_dyna
/ nume_ddl = CREA_ELEM_SSD(
    ◆ MODELE = modele,
    ◆ CHAM_MATER = cham_mater,
    ◇ CARA_ELEM = cara_elem,
    ◇ NUME_DDL = co,
    ◇ CHARGE = char_ther / char_meca / char_acou,
    ◆ INTERFACE = _F(
         ◇ & NOM = text,
           & TYPE = / "MNEAL",
                    / "CRAIGB",
                    / "CB_HARMO",
         ◆ / GROUP_NO = grno,
         ◇ FREQ = float (défaut: 1.0),
         ◇ MASQUE = text,
      ),
    ◆ BASE_MODALE = _F(
         ◆ TYPE = / "CLASSIQUE",
                  / "RITZ",
         # Si: equal_to("TYPE", 'RITZ')
             ◇ TYPE_MODE = / "STATIQUE",
                           / "INTERFACE" (par défaut),
             # Si: equal_to("TYPE_MODE", 'INTERFACE')
                 ◇ NMAX_MODE_INTF = int (défaut: 10),
      ),
    ◇ INFO = / 1 (par défaut),
             / 2,
    ⟐ 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),
             ◇ ELIM_LAGR = / "OUI",
                           / "NON" (par défaut),
             ◇ STOP_SINGULIER = / "OUI" (par défaut),
                                / "NON",
         # Si: equal_to("METHODE", 'LDLT')
             ◇ RENUM = "RCMK",
             ◇ NPREC = int (défaut: 8),
             ◇ ELIM_LAGR = / "OUI",
                           / "NON" (par défaut),
             ◇ STOP_SINGULIER = / "OUI" (par défaut),
                                / "NON",
         # 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 = / "OUI",
                           / "NON",
                           / "LAGR2" (par défaut),
             ◇ STOP_SINGULIER = / "OUI" (par défaut),
                                / "NON",
             ◇ 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),
             ◇ POSTTRAITEMENTS = / "SANS",
                                 / "AUTO" (par défaut),
                                 / "FORCE",
                                 / "MINI",
             ◇ PCENT_PIVOT = int (défaut: 35),
             ◇ NB_RHS = int (défaut: 1),
             ◇ RESI_RELA = float (défaut: -1.0),
             ◇ GESTION_MEMOIRE = / "IN_CORE",
                                 / "OUT_OF_CORE",
                                 / "AUTO" (par défaut),
                                 / "EVAL",
         # Si: equal_to("METHODE", 'GCPC')
             ◇ ELIM_LAGR = / "OUI",
                           / "NON" (par défaut),
             ◇ 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')
             ◇ ELIM_LAGR = / "OUI",
                           / "NON" (par défaut),
             ◇ 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",
      ),
    ⟐ CALC_FREQ = _F(
         ◇ STOP_ERREUR = / "OUI" (par défaut),
                         / "NON",
         ◇ OPTION = / "PLUS_PETITE" (par défaut),
                    / "BANDE",
                    / "CENTRE",
                    / "SANS",
         # Si: equal_to("OPTION", 'PLUS_PETITE')
             ◇ NMAX_FREQ = int (défaut: 10),
         # Si: equal_to("OPTION", 'CENTRE')
             ◆ FREQ = float,
             ◇ AMOR_REDUIT = float,
             ◇ NMAX_FREQ = int (défaut: 10),
         # Si: (equal_to("OPTION", 'BANDE'))
             ◇ NMAX_FREQ = int (défaut: 9999),
             ◆ FREQ = float,
         ◇ APPROCHE = / "REEL" (par défaut),
                      / "IMAG",
                      / "COMPLEXE",
         ◇ DIM_SOUS_ESPACE = int,
      ),
)


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

Déroulement du calcul#

Cet opérateur permet de créer facilement un macro-élément dynamique réel (sans amortissement) en renseignant uniquement les caractéristiques mécaniques du modèle et les interfaces associés à la sous-structure.

Il enchaîne les opérations suivantes:

  • création des matrices de rigidité et de masse de la sous-structure,

  • calcul des modes normaux de la sous-structure,

  • définition des interfaces associés à la sous-structure,

  • calcul des modes statiques ou des modes d’interface,

  • définition de la base de projection,

  • calcul du macro-élément dynamique.

Pour sa mise en œuvre, l’utilisateur peut s’inspirer des modélisations «e» et «f» du cas test SDLD106. Ces modélisations correspondent respectivement aux modélisations «b» et «d» du même cas test.

Opérande MODELE#

♦ MODELE = modele

modele: le modèle qui contient les éléments constituant la sous-structure.


Opérande NUME_DDL#

◊ NUME_DDL = nu

nu: numérotation des degrés de liberté affectée à la sous-structure.


Remarque:

Cette numérotation est nécessaire si on veut calculer la réponse de la structure assemblée due à un chargement appliqué à la sous-structure par exemple. On a besoin de la numérotation afin de pouvoir assembler le vecteur élémentaire selon la numérotation des degrés de liberté de la sous-structure.

On écrit alors: NUME_DDL = CO(“nume”) , où nume désigne la numérotation que l’on souhaite donnée aux degrés de liberté de la sous-structure.

Opérande CHAM_MATER#

♦ CHAM_MATER = chmat

chmat : nom du champ de matériau où sont définies les caractéristiques des matériaux.

Opérande CARA_ELEM#

◊ CARA_ELEM = carele

carele : caractéristiques élémentaires des éléments de poutre, coque ou des éléments discrets si la sous-structure en contient.

Opérande CHARGE#

◊ CHARGE = chg

chg : chargement appliqué à la sous-structure.

Mot-clé INTERFACE#

Le mot clé facteur INTERFACE permet de définir la ou les interfaces associées à la sous-structure. Les mots-clés associés à ce mot clé facteur sont identiques au mot clé facteur INTERFACE de l’opérateur DEFI_INTERF_DYNA [U4.64.01]. On saisit également ici la valeur de la fréquence utilisée pour le calcul des modes contraints harmoniques. La valeur par défaut, pour cette fréquence est égale à 1.

On applique la règle de surcharge. Si la valeur de la fréquence diffère entre les différentes interfaces alors on informe l’utilisateur à l’aide d’une alarme qui précise la valeur de la fréquence effectivement prise en compte.

Mot clé BASE_MODALE#

Le mot clé facteur BASE_MODALE permet de spécifier le type de base sur laquelle la sous-structure est projetée.

Opérande TYPE#

Cette opérande définit le type de la base de projection.


♦ TYPE=    / 'CLASSIQUE'

/ “RITZ”

Une base de type CLASSIQUE est constituée de modes normaux et de modes contraints ou de modes d’attache en fonction du type de l’interface. Le calcul des modes normaux se fait suivant les indications fournies dans le mot clé facteur CALC_FREQ.

Opérande TYPE_MODE#

◊ TYPE_MODE=    / 'INTERFACE'            [DEFAUT]

/ “STATIQUE”

L’option TYPE = “RITZ” permet de préciser le type de modes à ajouter aux modes normaux. L’utilisateur peut choisir des modes de type STATIQUE (relevés statiques aux degrés de liberté des noeuds d’interface) ou de type INTERFACE (modes d’interface). Pour le cas particulier où on ne souhaite pas utiliser des modes normaux, on choisit OPTION = “SANS” dans le mot clé CALC_FREQ.

Opérande NMAX_MODE_INTF#

◊ NMAX_MODE_INTF= / 10 [DEFAUT]

/ nmintf

NMAX_MODE_INTF correspond au nombre de modes d’interface à prendre en compte. On considère ici les nmintf premiers modes d’interface (nmintf > 0).

Mot-clé CALC_FREQ#


Ce mot-clé facteur permet de choisir le contenu fréquentiel des modes normaux. Les opérandes associés à ce mot-clé facteur sont identiques à ceux définis pour CALC_MODES [U4.52.02]. Une particularité pour l’option BANDE, l’opérande FREQ permet de saisir une liste de fréquence et on effectue les calculs modaux sur les différents intervalles de la liste.

On choisit OPTION = “SANS” si on ne souhaite pas calculer des modes normaux.

Le mot-clé STOP_ERREUR permet d’indiquer à l’opérateur s’il doit s’arrêter (“OUI”) ou continuer (“NON”) dans le cas où l’un des critères de contrôle de la qualité des modes calculés n’est pas vérifié. Ce mot-clé est équivalent au mot-clé STOP_ERREUR du mot-clé facteur VERI_MODE de CALC_MODES.

Remarque:

Afin de de ne pas surcharger la commande, ce mot clé facteur ne permet pas de saisir les paramètres COEF_DIM_ESPACE , NMAX_ITER_SHIFT , PREC_SHIFT , SEUIL_FREQ et STOP FREQ_VIDE . Par contre, l’utilisateur peut saisir la dimension du sous-espace ( DIM_SOUS_ESPACE ) en cas de besoin. Les valeurs choisies pour le calcul des modes normaux sont les valeurs par défaut de ces paramètres dans CALC_MODES .

Mot-clé SOLVEUR#

Mot-clé facultatif, voir [U4.50.01].

Opérande INFO#

Cette opérande permet d’imprimer plus ou moins d’information sur le macro-élément crée dans le fichier “MESSAGE”.

Exemple d’utilisation#

Cet exemple est extrait du cas test SDLS106e.

MACEL1 = CREA_ELEM_SSD(

MODELE = MODELE1,

CHARGE = CHARGE_1,

CHAM_MATER = CHAMAT1,

CARA_ELEM = PARAM1,

INTERFACE = _F( NOM = “GAUCHE”,

TYPE = “CRAIGB”,

GROUP_NO = “GAUCHE”,

MASQUE = (“DX”,”DY”),),

BASE_MODALE = _F( TYPE = “RITZ”,

NMAX_MODE_INTF = 20,),

CALC_FREQ = _F(NMAX_FREQ = 6,),

)