u4.53.03 Opérateur DYNA_VIBRA#
Syntaxe#
/ acou_harmo
/ dyna_harmo
/ dyna_trans
/ harm_gene
/ tran_gene = DYNA_VIBRA(
◇ reuse = <objet de RESULTAT>,
◆ BASE_CALCUL = / "GENE",
/ "PHYS",
◆ TYPE_CALCUL = / "HARM",
/ "TRAN",
# Si: equal_to("BASE_CALCUL", 'PHYS')
◇ MODELE = modele,
◇ CHAM_MATER = cham_mater,
◇ CARA_ELEM = cara_elem,
# Si: equal_to("TYPE_CALCUL", 'TRAN') and equal_to("BASE_CALCUL", 'PHYS')
◆ MATR_MASS = matr_asse_depl_r,
◆ MATR_RIGI = matr_asse_depl_r,
◇ MATR_AMOR = matr_asse_depl_r,
◇ OBSERVATION = _F(
◇ 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 = text,
/ NOM_VARI = text,
◇ EVAL_CMP = / "FORMULE",
/ "VALE" (par défaut),
◇ INST = float,
◇ LIST_INST = listr8,
◇ PAS_OBSE = int,
◇ CRITERE = / "ABSOLU",
/ "RELATIF" (par défaut),
◆ NOM_CHAM = / "ACCE",
/ "DEPL",
/ "VITE",
# Si: (equal_to("EVAL_CMP", 'FORMULE'))
◆ FORMULE = formule,
# Si: is_in("NOM_CHAM", ('DEPL','VITE','ACCE','TEMP','FORC_NODA','CONT_NOEU','DEPL_ABSOLU','VITE_ABSOLU','ACCE_ABSOLU'))
◆ / TOUT = "OUI" (ou non renseigné),
/ NOEUD = no,
/ GROUP_NO = grno,
/ GROUP_MA = grma,
/ MAILLE = ma,
# Si: is_in("NOM_CHAM", ('SIEF_ELGA','EPSI_ELGA','VARI_ELGA'))
◆ / TOUT = "OUI" (ou non renseigné),
/ GROUP_MA = grma,
/ MAILLE = ma,
◇ EVAL_ELGA = / "MAX",
/ "MIN",
/ "VALE" (par défaut),
# Si: (equal_to("EVAL_ELGA", 'VALE'))
◆ POINT = int,
◇ SOUS_POINT = int,
# Si: (equal_to("NOM_CHAM", 'CONT_ELEM'))
◆ / TOUT = "OUI" (ou non renseigné),
/ GROUP_MA = grma,
/ MAILLE = ma,
# Si: (equal_to("CRITERE", 'RELATIF'))
◇ PRECISION = float (défaut: 1e-06),
# Si: (equal_to("CRITERE", 'ABSOLU'))
◆ PRECISION = float,
),
◇ AMOR_MODAL = _F(
◇ / AMOR_REDUIT = float,
/ LIST_AMOR = listr8,
◆ MODE_MECA = mode_meca,
◇ NB_MODE = int,
),
# Si: equal_to("TYPE_CALCUL", 'TRAN') and equal_to("BASE_CALCUL", 'GENE')
◆ MATR_MASS = matr_asse_gene_r,
◆ MATR_RIGI = matr_asse_gene_r,
/ MATR_AMOR = matr_asse_gene_r,
◇ / AMOR_MODAL = _F(
◇ / AMOR_REDUIT = float,
/ LIST_AMOR = listr8,
),
◇ VITESSE_VARIABLE = / "NON" (par défaut),
/ "OUI",
# Si: equal_to("VITESSE_VARIABLE", 'OUI')
◆ MATR_GYRO = matr_asse_gene_r,
◆ VITE_ROTA = fonction / formule,
◇ MATR_RIGY = matr_asse_gene_r,
◇ ACCE_ROTA = fonction / formule,
# Si: equal_to("VITESSE_VARIABLE", 'NON')
◇ VITE_ROTA = float (défaut: 0.0),
# Si: equal_to("TYPE_CALCUL", 'HARM') and equal_to("BASE_CALCUL", 'PHYS')
◆ MATR_MASS = matr_asse_depl_r / matr_asse_pres_c,
◆ MATR_RIGI = matr_asse_depl_c / matr_asse_depl_r / matr_asse_pres_c,
/ MATR_AMOR = matr_asse_depl_r / matr_asse_pres_c,
◇ / AMOR_MODAL = _F(
◇ / AMOR_REDUIT = float,
/ LIST_AMOR = listr8,
),
◇ MATR_IMPE_PHI = matr_asse_depl_r,
# Si: exists("MATR_AMOR") and exists("MATR_IMPE_PHI")
◇ AMOR_FLUI = / "NON",
/ "OUI" (par défaut),
# Si: equal_to("TYPE_CALCUL", 'HARM') and equal_to("BASE_CALCUL", 'GENE')
◆ MATR_MASS = matr_asse_gene_r,
◆ MATR_RIGI = matr_asse_gene_c / matr_asse_gene_r,
◇ MATR_AMOR = matr_asse_gene_r,
◇ MATR_IMPE_PHI = matr_asse_gene_r,
◇ AMOR_MODAL = _F(
◇ / AMOR_REDUIT = float,
/ LIST_AMOR = listr8,
),
# Si: exists("MATR_AMOR") and exists("MATR_IMPE_PHI")
◇ AMOR_FLUI = / "NON",
/ "OUI" (par défaut),
◇ RESULTAT = dyna_harmo / harm_gene,
# Si: equal_to("TYPE_CALCUL", 'HARM')
◆ / FREQ = float,
/ LIST_FREQ = listr8,
◇ / NOM_CHAM = / "ACCE",
/ "DEPL",
/ "VITE",
/ TOUT_CHAM = "OUI" (ou non renseigné),
# Si: equal_to("TYPE_CALCUL", 'TRAN')
⟐ SCHEMA_TEMPS = _F(
# Si: equal_to("BASE_CALCUL",'GENE')
◇ SCHEMA = / "ADAPT_ORDRE1",
/ "ADAPT_ORDRE2",
/ "DEVOGE",
/ "DIFF_CENTRE",
/ "ITMI",
/ "NEWMARK",
/ "RUNGE_KUTTA_32" (par défaut),
/ "RUNGE_KUTTA_54",
/ "TRBDF2",
# Si: equal_to("SCHEMA", 'NEWMARK')
◇ BETA = float (défaut: 0.25),
◇ GAMMA = float (défaut: 0.5),
# Si: equal_to("SCHEMA", 'RUNGE_KUTTA_54') or equal_to("SCHEMA", 'RUNGE_KUTTA_32') or equal_to("SCHEMA", 'DEVOGE')
◇ TOLERANCE = float (défaut: 1e-05),
◇ ALPHA = float (défaut: 0.0),
# Si: equal_to("SCHEMA", 'ADAPT_ORDRE1') or equal_to("SCHEMA", 'ADAPT_ORDRE2')
◇ VITE_MIN = / "MAXI",
/ "NORM" (par défaut),
◇ COEF_MULT_PAS = float (défaut: 1.1),
◇ COEF_DIVI_PAS = float (défaut: 1.3333334),
◇ PAS_LIMI_RELA = float (défaut: 1e-06),
◇ NB_POIN_PERIODE = int (défaut: 50),
# Si: is_in("SCHEMA", ('RUNGE_KUTTA_54','RUNGE_KUTTA_32','DEVOGE','ADAPT_ORDRE1','ADAPT_ORDRE2'))
◇ PAS_MINI = float,
◇ PAS_MAXI = float,
◇ NMAX_ITER_PAS = int (défaut: 16),
# Si: not equal_to("BASE_CALCUL",'GENE')
◇ SCHEMA = / "ADAPT_ORDRE1",
/ "ADAPT_ORDRE2",
/ "DEVOGE",
/ "DIFF_CENTRE",
/ "ITMI",
/ "NEWMARK" (par défaut),
/ "RUNGE_KUTTA_32",
/ "RUNGE_KUTTA_54",
/ "WILSON",
# Si: equal_to("SCHEMA", 'NEWMARK')
◇ BETA = float (défaut: 0.25),
◇ GAMMA = float (défaut: 0.5),
# Si: equal_to("SCHEMA", 'WILSON')
◇ THETA = float (défaut: 1.4),
# Si: equal_to("SCHEMA", 'RUNGE_KUTTA_54') or equal_to("SCHEMA", 'RUNGE_KUTTA_32') or equal_to("SCHEMA", 'DEVOGE')
◇ TOLERANCE = float (défaut: 1e-05),
◇ ALPHA = float (défaut: 0.0),
# Si: equal_to("SCHEMA", 'ADAPT_ORDRE1') or equal_to("SCHEMA", 'ADAPT_ORDRE2')
◇ VITE_MIN = / "MAXI",
/ "NORM" (par défaut),
◇ COEF_MULT_PAS = float (défaut: 1.1),
◇ COEF_DIVI_PAS = float (défaut: 1.3333334),
◇ PAS_LIMI_RELA = float (défaut: 1e-06),
◇ NB_POIN_PERIODE = int (défaut: 50),
# Si: is_in("SCHEMA", ('RUNGE_KUTTA_54','RUNGE_KUTTA_32','DEVOGE','ADAPT_ORDRE1','ADAPT_ORDRE2'))
◇ PAS_MINI = float,
◇ PAS_MAXI = float,
◇ NMAX_ITER_PAS = int (défaut: 16),
),
◆ INCREMENT = _F(
◆ / LIST_INST = listr8,
/ PAS = float,
# Si: exists("LIST_INST")
◇ / NUME_FIN = int,
/ INST_FIN = float,
# Si: exists("PAS")
◇ INST_INIT = float,
◆ INST_FIN = float,
◇ VERI_PAS = / "NON",
/ "OUI" (par défaut),
),
# Si: equal_to("TYPE_CALCUL", 'TRAN') and equal_to("BASE_CALCUL", 'GENE')
◇ ETAT_INIT = _F(
◇ / RESULTAT = tran_gene,
/ DEPL = vect_asse_gene,
◇ / VITE = vect_asse_gene,
# Si: exists("RESULTAT")
◇ / NUME_ORDRE = int,
/ INST_INIT = float,
# Si: exists("INST_INIT")
◇ CRITERE = / "ABSOLU",
/ "RELATIF" (par défaut),
# Si: (equal_to("CRITERE", 'RELATIF'))
◇ PRECISION = float (défaut: 1e-06),
# Si: (equal_to("CRITERE", 'ABSOLU'))
◆ PRECISION = float,
),
# Si: equal_to("TYPE_CALCUL", 'TRAN') and equal_to("BASE_CALCUL", 'PHYS')
◇ ETAT_INIT = _F(
◆ | RESULTAT = dyna_trans,
| DEPL = cham_no,
| VITE = cham_no,
| ACCE = cham_no,
# Si: exists("RESULTAT")
◇ / NUME_ORDRE = int,
/ INST_INIT = float,
# Si: exists("INST_INIT")
◇ CRITERE = / "ABSOLU",
/ "RELATIF" (par défaut),
# Si: (equal_to("CRITERE", 'RELATIF'))
◇ PRECISION = float (défaut: 1e-06),
# Si: (equal_to("CRITERE", 'ABSOLU'))
◆ PRECISION = float,
),
# Si: equal_to("BASE_CALCUL", 'PHYS') and equal_to("TYPE_CALCUL", 'TRAN')
◇ ARCHIVAGE = _F(
◇ PAS_ARCH = int,
◇ / LIST_INST = listr8,
/ INST = float,
# Si: (exists("LIST_INST") or 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,
◇ CHAM_EXCLU = / "ACCE",
/ "DEPL",
/ "VITE",
),
# Si: not equal_to("BASE_CALCUL", 'PHYS') and equal_to("TYPE_CALCUL", 'TRAN')
◇ ARCHIVAGE = _F(
◆ | PAS_ARCH = int,
| LIST_INST = listr8,
| INST = float,
),
# Si: equal_to("BASE_CALCUL", 'PHYS')
◇ ENERGIE = _F(
◇ CALCUL = "OUI",
),
# Si: equal_to("TYPE_CALCUL", 'HARM') and equal_to("BASE_CALCUL", 'PHYS')
◆ | EXCIT = _F(
◆ / VECT_ASSE = cham_no,
/ CHARGE = char_cine_meca / char_meca,
◆ / FONC_MULT_C = fonction_c / formule_c,
/ FONC_MULT = fonction / formule / nappe,
/ COEF_MULT = float,
/ COEF_MULT_C = complex,
◇ PHAS_DEG = float (défaut: 0.0),
◇ PUIS_PULS = int (défaut: 0),
),
| EXCIT_RESU = _F(
◆ RESULTAT = dyna_harmo,
◆ COEF_MULT_C = complex,
),
# Si: equal_to("TYPE_CALCUL", 'HARM') and equal_to("BASE_CALCUL", 'GENE')
◆ | EXCIT = _F(
◆ VECT_ASSE_GENE = vect_asse_gene,
◆ / FONC_MULT_C = fonction_c / formule_c,
/ FONC_MULT = fonction / formule / nappe,
/ COEF_MULT = float,
/ COEF_MULT_C = complex,
◇ PHAS_DEG = float (défaut: 0.0),
◇ PUIS_PULS = int (défaut: 0),
),
| EXCIT_RESU = _F(
◆ RESULTAT = harm_gene,
◆ COEF_MULT_C = complex,
),
| CHAR_GENE = char_gene,
# Si: equal_to("TYPE_CALCUL", 'TRAN') and equal_to("BASE_CALCUL", 'PHYS')
◇ EXCIT = _F(
◆ / VECT_ASSE = cham_no,
/ CHARGE = char_cine_meca / char_meca,
◇ / FONC_MULT = fonction / formule / nappe,
/ COEF_MULT = float,
◇ / ACCE = fonction / formule / nappe,
◇ & VITE = fonction / formule / nappe,
& ◆ DEPL = fonction / formule / nappe,
◇ MULT_APPUI = / "NON" (par défaut),
/ "OUI",
# Si: equal_to("MULT_APPUI", 'OUI')
◇ DIRECTION = float,
◇ GROUP_NO = grno,
),
◇ MODE_STAT = mode_meca,
◇ EXCIT_RESU = _F(
◆ RESULTAT = dyna_trans,
◆ COEF_MULT = float,
),
# Si: equal_to("TYPE_CALCUL", 'TRAN') and equal_to("BASE_CALCUL", 'GENE')
◇ EXCIT = _F(
◆ / VECT_ASSE_GENE = vect_asse_gene,
/ NUME_ORDRE = int,
◆ / FONC_MULT = fonction / formule / nappe,
/ COEF_MULT = float,
/ ACCE = fonction / formule / nappe,
◇ & VITE = fonction / formule / nappe,
& ◆ DEPL = fonction / formule / nappe,
◇ / MULT_APPUI = "OUI" (ou non renseigné),
/ CORR_STAT = "OUI" (ou non renseigné),
# Si: equal_to("MULT_APPUI", 'OUI')
◇ DIRECTION = float,
◇ GROUP_NO = grno,
# Si: equal_to("CORR_STAT", 'OUI')
◆ D_FONC_DT = fonction / formule / nappe,
◆ D_FONC_DT2 = fonction / formule / nappe,
),
◇ / MODE_STAT = mode_meca,
/ MODE_CORR = mode_meca / mult_elas,
◇ EXCIT_RESU = _F(
◆ RESULTAT = tran_gene,
◇ COEF_MULT = float (défaut: 1.0),
),
◇ COMPORTEMENT = _F(
◆ RELATION = / "ANTI_SISM",
/ "CHOC_ELAS_TRAC",
/ "DIS_CHOC",
/ "DIS_ECRO_TRAC",
/ "DIS_VISC",
/ "FLAMBAGE",
/ "RELA_EFFO_DEPL",
/ "RELA_EFFO_VITE",
/ "ROTOR_FISS",
# Si: equal_to("RELATION", 'DIS_CHOC')
◇ INTITULE = text,
◆ / GROUP_MA = grma,
/ GROUP_NO_1 = grno,
◇ / GROUP_NO_2 = grno,
◆ OBSTACLE = table_fonction,
◇ ORIG_OBST = float,
◆ NORM_OBST = float,
◇ ANGL_VRIL = float,
◇ JEU = float (défaut: 1.0),
◇ DIST_1 = float,
◇ DIST_2 = float,
◇ SOUS_STRUC_1 = text,
◇ SOUS_STRUC_2 = text,
◇ REPERE = text (défaut: "GLOBAL"),
◆ RIGI_NOR = float,
◇ AMOR_NOR = float (défaut: 0.0),
◇ RIGI_TAN = float (défaut: 0.0),
◇ AMOR_TAN = float,
◇ FROTTEMENT = / "COULOMB",
/ "COULOMB_STAT_DYNA",
/ "NON" (par défaut),
# Si: equal_to("FROTTEMENT", 'COULOMB')
◆ COULOMB = float,
◇ UNIDIRECTIONNEL = / "NON" (par défaut),
/ "OUI",
# Si: equal_to("FROTTEMENT", 'COULOMB_STAT_DYNA')
◆ COULOMB_STAT = float,
◆ COULOMB_DYNA = float,
◇ UNIDIRECTIONNEL = / "NON" (par défaut),
/ "OUI",
# Si: equal_to("RELATION", 'ROTOR_FISS')
◇ ANGL_INIT = float (défaut: 0.0),
◇ ANGL_ROTA = fonction / formule,
◇ / GROUP_NO_G = grno,
◆ / GROUP_NO_D = grno,
◆ K_PHI = fonction / formule,
◆ DK_DPHI = fonction / formule,
# Si: equal_to("RELATION", 'FLAMBAGE')
◇ INTITULE = text,
◆ / GROUP_NO_1 = grno,
◇ / GROUP_NO_2 = grno,
◆ OBSTACLE = table_fonction,
◇ ORIG_OBST = float,
◆ NORM_OBST = float,
◇ ANGL_VRIL = float,
◇ JEU = float (défaut: 1.0),
◇ DIST_1 = float,
◇ DIST_2 = float,
◇ REPERE = text (défaut: "GLOBAL"),
◆ FX = fonction,
◆ RIGI_NOR = fonction,
◆ AMOR_NOR = fonction,
◇ CRIT_AMOR = / "EXCLUS",
/ "INCLUS" (par défaut),
# Si: equal_to("RELATION", 'ANTI_SISM')
◆ / GROUP_NO_1 = grno,
◆ / GROUP_NO_2 = grno,
◇ RIGI_K1 = float (défaut: 0.0),
◇ RIGI_K2 = float (défaut: 0.0),
◇ SEUIL_FX = float (défaut: 0.0),
◇ C = float (défaut: 0.0),
◇ PUIS_ALPHA = float (défaut: 0.0),
◇ DX_MAX = float (défaut: 1.0),
# Si: equal_to("RELATION", 'DIS_VISC')
◆ / GROUP_NO_1 = grno,
◆ / GROUP_NO_2 = grno,
◆ / K1 = float,
/ UNSUR_K1 = float,
◆ / K2 = float,
/ UNSUR_K2 = float,
◆ / K3 = float,
/ UNSUR_K3 = float,
◆ C = float,
◇ PUIS_ALPHA = float (défaut: 0.5),
◇ ITER_INTE_MAXI = int (défaut: 20),
◇ RESI_INTE = float (défaut: 1e-06),
# Si: equal_to("RELATION", 'DIS_ECRO_TRAC')
◆ / GROUP_NO_1 = grno,
◆ / GROUP_NO_2 = grno,
◆ / FX = fonction,
/ FTAN = fonction,
# Si: exists("FTAN")
◆ ECROUISSAGE = / "CINEMATIQUE",
/ "ISOTROPE",
◇ ITER_INTE_MAXI = int (défaut: 20),
◇ RESI_INTE = float (défaut: 1e-06),
# Si: equal_to("RELATION", 'CHOC_ELAS_TRAC')
◆ / GROUP_NO_1 = grno,
◆ / GROUP_NO_2 = grno,
◇ DIST_1 = float,
◇ DIST_2 = float,
◆ FX = fonction,
# Si: equal_to("RELATION", 'RELA_EFFO_DEPL')
◆ / GROUP_NO = grno,
◇ SOUS_STRUC = text,
◇ NOM_CMP = text,
◆ FONCTION = fonction / formule / nappe,
# Si: equal_to("RELATION", 'RELA_EFFO_VITE')
◆ / GROUP_NO = grno,
◇ SOUS_STRUC = text,
◇ NOM_CMP = text,
◆ FONCTION = fonction / formule / nappe,
),
◇ & BASE_ELAS_FLUI = melasflu,
& NUME_VITE_FLUI = int,
◇ VERI_CHOC = _F(
◇ STOP_CRITERE = / "NON",
/ "OUI" (par défaut),
◇ SEUIL = float (défaut: 0.5),
),
# Si: exists("BASE_ELAS_FLUI")
◇ TRAITEMENT_NONL = "IMPLICITE",
# Si: not exists("BASE_ELAS_FLUI")
◇ TRAITEMENT_NONL = / "EXPLICITE" (par défaut),
/ "IMPLICITE",
# Si: equal_to("BASE_CALCUL", 'GENE') and equal_to("TYPE_CALCUL", 'HARM')
⟐ SOLVEUR = _F(
◇ METHODE = / "LDLT" (par défaut),
/ "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",
/ "FR" (par défaut),
/ "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),
◇ 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",
# 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),
),
# Si: equal_to("BASE_CALCUL", 'PHYS') and equal_to("TYPE_CALCUL", 'HARM')
⟐ SOLVEUR = _F(
◇ METHODE = / "LDLT",
/ "MULT_FRONT",
/ "MUMPS" (par défaut),
# 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",
/ "FR" (par défaut),
/ "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),
◇ 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",
# 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),
),
# Si: equal_to("BASE_CALCUL", 'PHYS') and equal_to("TYPE_CALCUL", 'TRAN')
⟐ 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",
# 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),
),
# Si: equal_to("BASE_CALCUL", 'GENE') and equal_to("TYPE_CALCUL", 'TRAN')
⟐ SOLVEUR = _F(
◇ METHODE = / "LDLT" (par défaut),
/ "MULT_FRONT",
/ "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",
/ "FR" (par défaut),
/ "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),
◇ 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",
# 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),
),
◇ TITRE = text,
◇ INFO = / 1,
/ 2,
# Si: equal_to("BASE_CALCUL", 'GENE') and equal_to("TYPE_CALCUL", 'TRAN')
◇ IMPRESSION = _F(
◇ / TOUT = "OUI" (ou non renseigné),
/ | UNITE_DIS_VISC = unit,
| INST_FIN = float,
| INST_INIT = float,
| NIVEAU = / "DEPL_LOC",
/ "FORC_LOC",
/ "TAUX_CHOC",
/ "VITE_LOC",
◇ / UNITE_DIS_ECRO_TRAC = unit,
),
)
◆ : obligatoire
◇ : optionnel
⟐ : présent par défaut
& : ensemble
/ : un seul parmi
| : plusieurs choix possibles
Opérandes d’indirection#
TYPE_CALCUL#
Ce mot clé qui permet de faire le choix entre le calcul transitoire (TYPE_CALCUL=”TRAN”) et le calcul harmonique (TYPE_CALCUL=”HARM).
BASE_CALCUL#
Ce mot-clé permet de faire le choix entre un calcul sur base physique (BASE_CALCUL=”PHYS”) et un calcul sur base modale (BASE_CALCUL=”GENE”).
Les mots clés spécifiques à chaque type de calcul sont décrits dans les paragraphes suivants:
Opérandes communes à tout type de calcul#
Opérande TITRE#
◊ TITRE= titre
Titre de la structure de données résultat [U4.03.01].
Opérande SOLVEUR#
◊ SOLVEUR
Ce mot clé facteur est facultatif. Il permet de définir la méthode de résolution du système. La syntaxe est décrite dans le document [U4.50.01].
**Remarque:la méthode* MULT_FRONT n’est pas disponible pour la résolution des systèmes avec des matrices généralisées.
Calcul de réponse transitoire sur base modale#
Considérons le modèle aux éléments finis d’une structure linéaire, présentant des mécanismes de dissipations internes, soumise à des efforts extérieurs, pouvant aussi bien être connus a priori (chargements) que devant être évalués au fur et à mesure (efforts de chocs, contact, etc.). Dans le domaine temporel, la relation d’équilibre s’écrit:
où \({\mathrm{K}}_{e}\) est la matrice de raideur de la structure, \({\mathrm{D}}_{v}\) la matrice associée à la dissipation visqueuse, et \(\mathrm{M}\) la matrice de masse. On note par ailleurs \(\mathrm{x}\) le vecteur des degrés de liberté. Le terme des efforts extérieurs est défini par le produit d’une matrice de localisation des efforts \(\mathrm{B}\) et d’un vecteur \(\mathrm{u}\) précisant l’évolution temporelle de l’excitation. Cette écriture permet de séparer les composantes spatiales et temporelles d’un effort souvent noté \(\mathrm{f}(t)\). On aura donc, dans ce cas :
La résolution du problème sur la base du modèle complet présenté dans la relation ci-dessus peut être rédhibitoire pour des modèles de taille industrielle. Pour contourner cette difficulté, on se propose de construire un modèle réduit possédant les mêmes propriétés spectrales que le problème complet. On postule donc l’existence d’une base de réduction \({\mathrm{T}}_{r}\) qui permette la représentation raisonnable du comportement de la structure sur la bande de fréquence d’intérêt. Dans ces conditions, on a donc :
Les termes \({\mathrm{q}}_{r}\) de la combinaison linéaire correspondent aux amplitudes généralisées du problème complet projeté sur la base \({\mathrm{T}}_{r}\) . Ces amplitudes vérifient donc, dans le cas général :
On résout donc ici un système de plus petite taille dont les inconnues sont les amplitudes généralisées \({\mathrm{q}}_{r}\) .
\(\left[{\mathrm{T}}_{r}^{T}{\mathrm{K}}_{e}{\mathrm{T}}_{r}\right]\) désigne la matrice de raideur généralisée.
\(\left[{\mathrm{T}}_{r}^{T}{\mathrm{D}}_{v}{\mathrm{R}}_{r}\right]\) désigne la matrice d’amortissement généralisé.
\(\left[{\mathrm{T}}_{r}^{T}\mathrm{M}{\mathrm{T}}_{r}\right]\) désigne la matrice de masse généralisée.
La base \({\mathrm{T}}_{r}\) est composée dans la majorité des cas de modes propres de la structure étudiée. Cette sélection de modes peut être enrichie de réponses particulières, afin de mieux représenter la dynamique de la réponse, en évitant d’avoir recours à un trop grand nombre de modes propres [U2.06.04]. On pourra citer, pour les cas usuels :
Les corrections statiques associées à un point d’application d’un effort (externe, ou choc) calculées en imposant soit un effort unitaire, soit un déplacement unitaire ;
Les modes à accélérations imposées, pour représenter la réponse sismique, ou l’entrainement d’une sous-structure embarquée en translation par ses interfaces ;
Tout autre terme nécessaire à la bonne représentation de la réponse quasi statique de la structure ou de chaque sous-structure.
Ces termes correctifs peuvent être calculés via l’opérateur MODE_STATIQUE [U4.52.14] pour les cas génériques, ou par calcul direct, via MECA_STATIQUE [U4.51.01], ou MACR_ELAS_MULT [U4.51.02]. Tous ces vecteurs sont ensuite concaténés via l’opérateur DEFI_BASE_MODALE [U4.64.02]. Par abus de langage, on appellera par la suite cette famille de vecteurs «base modale».
Matrices généralisées#
Dans le cas d’un calcul par recombinaison modale, les matrices généralisées doivent être établies par l’opérateur PROJ_MATR_BASE [U4.63.12] ou par la macro-commande PROJ_BASE [U4.63.11], à partir de la même base modale.
Dans le cas d’un calcul par sous-structuration dynamique, les matrices généralisées doivent être établies par l’opérateur ASSE_MATR_GENE
à partir de la même numérotation généralisée.
♦ MATR_MASS = ma
Matrice de masse \(\mathrm{M}\)
du système généralisé.
Concept de type matr_asse_gene_R.
♦ MATR_RIGI = ri
Matrice de rigidité du système généralisé.
Concept de type matr_asse_gene_R.
◊ MATR_AMOR = am
Matrice d’amortissement du système généralisé.
Concept de type matr_asse_gene_R.
Cette option n’est pas disponible avec la méthode ‘DEVOGE’.
Mot-clé AMOR_MODAL#
Ce mot-clé permet de prendre en compte un amortissement équivalent à un amortissement modal décomposé sur une base de modes pré-calculée sous forme de concept de type mode_meca. Cet amortissement est globalement pris en compte dans l’équation d’équilibre dynamique comme une force correctrice au second membre \(-\mathrm{C}\dot{\mathrm{q}}\).
Opérandes AMOR_REDUIT / LIST_AMOR#
◊ /AMOR_REDUIT = la
Liste des amortissements réduits (\({\eta}_{1,}{\eta}_{2,}\mathrm{...},{\eta}_{n}\) pourcentages de l’amortissement critique) correspondants à chaque mode du système sous forme de liste de réels.
Cette option n’est pas disponible en sous-structuration dynamique car les amortissements réduits doivent être définis pour chaque sous-structure séparément (opérateur MACR_ELEM_DYNA [U4.65.01]).
Remarque : si le nombre d’amortissements réduits donnés est inférieur au nombre de vecteurs de base utilisés dans la base modale, les amortissements des vecteurs supplémentaires sont pris égaux au dernier amortissement de la liste.
/LIST_AMOR = l_amor
Nom du concept de type listr8 contenant la liste des amortissements réduits.
Schémas d’intégration. Mot clé SCHEMA_TEMPS#
Sous ce mot-clé on peut renseigner un schéma d’intégration avec, éventuellement, ses paramètres. Les schémas disponiblessont à déclarer sous l’opérande SCHEMA.
Opérande SCHEMA#
◊ SCHEMA
Choix de la méthode numérique de résolution. Dans le cas d’un calcul classique par recombinaison modale, l’utilisateur dispose de plusieurs méthodes de type explicite, d’une méthode intégrale et d’une méthode de type implicite.
Dans le cas d’un calcul par sous-structuration dynamique [R4.06.04], la méthode de calcul transitoire sur base modale calculée par sous-structuration supporte tous les schémas d’intégration évoqués. En revanche, la méthode de calcul transitoire sur les « bases » des sous-structures ne supporte que le schéma de type différence centrée et les schémas à pas de temps adaptatif.
SCHEMA = “NEWMARK” : schéma implicite d’ordre 2#
Ce schéma supporte le calcul avec prise en compte de l’ensemble des non-linéarités localisées disponibles. On peut préciser les paramètres d’intégration temporelle \(\beta\) et \(\gamma\) :
◊ BETA = beta
Valeur du paramètre \(\beta\) pour la méthode de NEWMARK. Par défaut \(\beta =0.25\) .
◊ GAMMA = gamm
Valeur du paramètre \(\gamma\) pour la méthode de NEWMARK. Par défaut \(\gamma =0.5\) .
SCHEMA = “DIFF_CENTRE” : schéma explicite d’ordre 2#
Ce schéma supporte le calcul avec prise en compte de l’ensemble des non-linéarités localisées disponibles. Sa formulation est une paramétrisation en accélérations ( Code_Aster ne propose pas de paramétrisation en déplacements pour ce schéma). Voir [R5.06.04]
SCHEMA = “DEVOGE” : schéma explicite d’ordre 4#
Le schéma de DEVOGELAERE supporte le calcul avec prise en compte de l’ensemble des non-linéarités localisées disponibles.
SCHEMA = “ADAPT_ORDRE2” : schéma explicite d’ordre 2#
Ce schéma (appelé “ADAPT” dans les versions antérieures du code) supporte le calcul avec prise en compte de l’ensemble des non-linéarités localisées disponibles. Cette méthode utilise le schéma des différences centrées, l’algorithme d’adaptation du pas de temps s’appuie sur le calcul d’une «fréquence apparente» :
On précise ci-après les opérandes spécifiques à la méthode d’intégration par pas de temps adaptatifs. Ce sont les opérandes suivants du mot clé facteur INCREMENT:
◊ NB_POIN_PERIODE = N
Nombre de points par période apparente. C’est ce paramètre qui fixe la précision du calcul. Il doit être au moins égal à 20; sa valeur par défaut (50) garantit une précision satisfaisante (de l’ordre de 1%) dans la plupart des cas.
◊ VITE_MIN =
Méthode de calcul de la vitesse de référence utilisée pour évaluer la fréquence apparente.
Quand le dénominateur de la fréquence apparente (\({x}_{n}-{x}_{n-1}\) ) devient faible, celle-ci peut devenir très élevée, ce qui conduit à un raffinement injustifié du pas de temps. Pour y remédier, l’algorithme utilise le critère suivant:
\({V}_{min}\) peut être calculé de deux façons différentes selon la valeur de VITE_MIN.
Si VITE_MIN = “NORM”: alors \({V}_{min}({t}_{n})=\frac{\parallel V({t}_{n})\parallel }{100}\) pour tous les degrés de liberté. Ce cas peut être utilisé:
si le système possède plusieurs degrés de liberté,
si l’ordre de grandeur du déplacement n’est pas trop différent selon les degrés de liberté.
Si VITE_MIN = “MAXI”: \({V}_{min}^{i}({t}_{n})=\frac{\underset{0<{t}_{p}<{t}_{n}}{\mathit{Max}}(\mid {V}^{i}({t}_{p})\mid )}{100}\) pour le degré de liberté \(i\) . Ce cas peut être utilisé:
si le système possède un petit nombre de degrés de liberté (de 1 à 3),
pour un système à plusieurs degrés de liberté, dans le cas où l’ordre de grandeur du déplacement est très différent selon les degrés de liberté (par exemple en présence de degrés de liberté de Lagrange en sous‑structuration),
si l’ordre de grandeur de la vitesse ne varie pas trop au cours du temps.
◊ NMAX_ITER_PAS = N
Nombre maximal de réductions du pas de temps par pas de calcul. Il est par défaut égal à 16, ce qui limite le coefficient de réduction du pas à \({0,75}^{16}={10}^{-2}\) par itération (lorsque le pas de temps est trop élevé, on reprend le calcul avec un pas plus faible: \(\Delta {t}_{n}'=0,75\Delta {t}_{n}\) ).
NMAX_ITER_PAS peut être:
augmenté pour permettre au pas de temps de chuter de façon plus brutale,
diminué si le pas de temps semble excessivement raffiné, par exemple en présence de discontinuités (frottement sec, excitation discontinue, …).
Si, à un instant donné, on atteint ce nombre maximal de réductions successives du pas de temps, alors le code va quand même considérer que le pas final est correct et passer au pas suivant. Un message d’alarme est alors émis, qui signale un éventuel risque de perte de précision et qui conseille à l’utilisateur de relancer le calcul avec des paramètres modifiés (en jouant sur PAS, NMAX_ITER_PAS et / ou COEF_DIVI_PAS) pour permettre de franchir la difficulté avec un pas de temps plus petit.
◊ COEF_MULT_PAS = cmp
Coefficient d’augmentation du pas lorsque l’erreur est suffisamment faible:
\(\Delta {t}_{n}<\frac{0,75}{{\mathit{Nf}}_{\mathit{APn}}}\mathrm{\Rightarrow }\Delta {t}_{n+1}=\text{cmp}\Delta {t}_{n}\) .
Sa valeur par défaut (\(\text{cmp}=1.1\) ) garantit stabilité et précision, mais il peut en général être augmenté (au plus jusqu’à \(1.3\) ) pour accélérer l’intégration.
◊ COEF_DIVI_PAS = cdp
Coefficient de raffinement du pas de temps (\(>1\) ) lorsque l’erreur est supérieure à 1, que le nombre d’itérations maximales (N_MAX_ITER_PAS) n’est pas atteint et que le pas de temps minimal n’est pas atteint:
\(\Delta {t}_{n}<\frac{1}{{\mathit{Nf}}_{\mathit{APn}}}\) , \({N}_{\mathit{iter}}<{N}_{\mathit{iter}\text{\_}max}\) et \(\Delta {t}_{n}>\text{plr}\Delta {t}_{\mathit{initial}}\)
\(\mathrm{\Rightarrow }\Delta {t}_{n}=\frac{\Delta {t}_{n}}{\text{cdp}}\)
La valeur par défaut est de \(1.33333334\) , soit une réduction d’un facteur \(0.75\) .
◊ PAS_LIMI_RELA = plr
Coefficient appliqué au pas de temps initial pour définir la limite de raffinement et donc le pas de temps minimal:
La valeur par défaut est de \(1.33333334\) , soit une réduction d’un facteur \(0.75\) .
\(\Delta {T}_{min}=\text{plr}\Delta {t}_{\mathit{initial}}\)
SCHEMA = “RUNGE_KUTTA_54” : schéma explicite à pas adaptatif.#
Ce schéma fait partie de la famille des schémas d’intégration de type Runge-Kutta. En particulier, il s’agit du schéma d’intégration explicite de Dormand-Prince(54) [R5.06.04] à pas de temps adaptatif.
Le schéma “RUNGE_KUTTA_54” supporte la prise en compte de toutes les non‑linéarités disponibles dans l’opérateur.
Le calcul du pas de temps optimal se fait par contrôle de l’erreur entre les approximations d’ordre 5 et 4 de la prédiction du vecteur d’état (concaténation des vecteurs de déplacement et vitesse).
Ce schéma s’appuie sur la condition de contrôle de l’erreur relative suivante:
Avec:
Où:
\({y}_{\mathit{i1}}\) est la valeur de la prédiction d’ordre 5 de la composante \(i\) du vecteur d’état \(y\)
\({\stackrel{ˆ}{y}}_{\mathrm{1i}}\) est la valeur de la prédiction d’ordre 4 de la composante \(i\) du vecteur d’état \(y\)
\(n\) est la taille du vecteur d’état \(y\)
\({y}_{\mathrm{0i}}\) est la valeur de la composante \(i\) du vecteur d’état \(y\) à l’état actuel
◊ TOLERANCE = tol
Valeur de contrôle d’erreur relative donnée par l’utilisateur. Par défaut elle vaut 1.E-3.
◊ ALPHA = alpha
Valeur de régularisation donnée par l’utilisateur intervenant dans l’expression de \({\mathit{sc}}_{i}\) . Par défaut elle vaut 1.E-3.
SCHEMA = “RUNGE_KUTTA_32” : schéma explicite à pas adaptatif.#
C’est le schéma par défaut pour l’analyse transitoire sur base modale.
Comme le schéma “RUNGE_KUTTA_54”, le schéma “RUNGE_KUTTA_32” fait partie de la famille des schémas d’intégration de type Runge-Kutta. Dans ce cas, il s’agit du schéma d’intégration explicite de Bogacki-Shampine(32) [R5.06.04] à pas de temps adaptatif.
Comme le schéma précédent, il supporte la prise en compte de l’ensemble des non-linéarités disponibles dans l’opérateur.
Pour ce schéma, le calcul du pas de temps optimal se fait par contrôle de l’erreur entre les approximations d’ordre 3 et 2 de la prédiction du vecteur d’état. Le calcul du pas de temps optimal, quant à lui, se fait de manière analogue au schéma précédent.
SCHEMA = “ADAPT_ORDRE1” : schéma explicite d’ordre 1#
Ce schéma est une variante du schéma précédent “ADAPT_ORDRE2”. C’est en fait une version du schéma d’Euler avec pas de temps adaptatif. En dehors de cette différence, ce schéma s’utilise de la même manière que le schéma adaptatif d’ordre 2: la syntaxe des mot-clés est la même et les méthodes de pilotage du pas de temps aussi.
SCHEMA = “ITMI” : schéma intégrale pour le calcul de la réponse de systèmes mécaniques très faiblement amortis#
Ce schéma d’intégration par méthode intégrale permet, pour les systèmes faiblement amortis, d’obtenir une réponse exacte à condition que les matrices dynamiques de masse, rigidité et d’amortissement soient diagonales.
SCHEMA = “TRBDF2” : schéma implicite d’ordre 2#
Ce schéma prédicteur-correcteur dissipatif supporte le calcul avec prise en compte de l’ensemble des non-linéarités localisées disponibles. Il possède de très bonnes propriétés de stabilité qui en font un bon candidat pour les problèmes raides.
Mot clé INCREMENT#
Opérandes LIST_INST/PAS/VERI_PAS/PAS_MINI/PAS_MAXI#
♦ / LIST_INST = l_temp
Concept liste de réels de type listr8.
Liste de réels définissant les instants \({t}_{i}\) de calcul de la solution
Schémas “RUNGE_KUTTA_54” et “RUNGE_KUTTA32” :
Pour les schémas de type Runge-Kutta, le mot clé LIST_INST n’est pas pris en compte.
/ PAS = dt
Schémas “DIFF_CENTRE”, “NEWMARK”, “ITMI” :
Pas de temps du calcul transitoire.
Schémas “ADAPT_ORDRE1” et “ADAPT_ORDRE2” :
Désigne le pas de temps initial utilisé par l’algorithme. Ce paramètre doit être suffisamment faible:
pour permettre le calcul des phases statiques (qui utilise toujours le pas de temps maximal),
pour démarrer correctement l’algorithme.
Il doit cependant être suffisamment élevé pour ne pas pénaliser l’ensemble du calcul.
Schémas “RUNGE_KUTTA_54”, “RUNGE_KUTTA32” et “DEVOGE” :
Désigne le pas de temps initial proposé par l’utilisateur. Si l’erreur de prédiction entre les ordres de contrôle vérifie \(\mathit{err}\le 1\) , alors il s’agit du premier pas de calcul. Sinon, l’algorithme choisit automatiquement le pas de temps nécessaire afin de vérifier cette condition. Par la suite, le choix du pas de temps dans les algorithmes de Runge-Kutta est géré automatiquement.
◊ VERI_PAS= rep
Vérification du pas de temps de calcul relativement au pas de temps limite déterminé en fonction de la fréquence la plus élevée des modes de la base modale considérée ou des bases des sous‑structures.
# Opérandes spécifiques à une intégration par pas de temps adaptatifs avec les schémas “ADAPT_ORDRE1”, “ADAPT_ORDRE2’ainsi que “RUNGE_KUTTA_54’et “RUNGE_KUTTA_32” et “DEVOGE”.
◊ PAS_MAXI = dtmax
Valeur maximale du pas de temps. Si les conditions d’augmentation du pas de temps sont remplies, le pas de temps courant pourra alors augmenter jusqu’à cette valeur limite.
Si l’utilisateur ne donne pas de valeur à ce paramètre facultatif, les schémas adaptatifs de type ADAPT_ORDRE1/2 estimeront une valeur notée \(\mathit{dts}\) à partir de la fréquence de coupure de la base (éventuellement corrigée par les raideurs de chocs). En revanche, les autres schémas adaptatifs (Runge-Kutta, De Vogelaere) n’auront aucune limitation supérieure en termes de pas de temps.
Pour retrouver le fonctionnement des versions antérieures du code, il suffit d’imposer :
\(\mathit{dtmax}=\mathit{dt}\) , donc la même valeur au paramètre PAS qu’à PAS_MAXI.
◊ PAS_MINI = dtmin
Valeur minimale du pas de temps. Si les conditions de diminution du pas de temps sont remplies, le pas de temps courant pourra alors diminuer jusqu’à cette valeur limite.
Si l’utilisateur ne donne pas de valeur à ce paramètre facultatif, alors le code calculera le pas de temps minimal proche de la précision de la machine.
Pour retrouver le fonctionnement des versions antérieures du code, il suffit donc de ne pas définir PAS_MINI.
Remarque importante: pour forcer un schéma d’intégration à passer en mode pas-constant, il suffit de choisir PAS_MAXI= PAS_MINI=PAS=dt
Opérandes INST_INIT/INST_FIN/NUME_FIN#
◊ INST_INIT= to
Méthodes ‘DIFF_CENTRE’, ‘DEVOGE’, ‘NEWMARK’, ‘ADAPT_ORDRE1’ et ‘ADAPT_ORDRE2’:
Instant de début du calcul transitoire. En cas de reprise, on utilise le mot clé ETAT_INIT : sous ce mot clé, l’instant initial est récupéré avec l’opérande INST_INIT ou pris égal au dernier instant de calcul précédent archivé. L’opérande INST_INIT doit donc être utilisé uniquement s’il n’y a pas de reprise d’un calcul précédent.
◊ /INST_FIN= tf
Instant de fin de la simulation.
/NUME_FIN= tf
Numéro de l’instant de fin de calcul dans LIST_INST
Mot clé ETAT_INIT#
Mot clé facteur qui permet une poursuite d’un calcul transitoire, en prenant comme état initial:
soit un résultat issu d’un calcul par synthèse modale précédent EXCIT(RESULTAT);
soit des déplacements et vitesses exprimés sous forme de vecteurs assemblés généralisés EXCIT(DEPL et VITE)
Remarques:
Cette fonctionnalité n’est pas disponible pour un calcul par sous-structuration transitoire sans double projection.
Les déplacements et vitesses généralisés doivent être établis par l’opérateur PROJ_VECT_BASE [U4.63.13] à partir de la base modale utilisée pour les matrices de rigidité généralisées ou par l’opérateur RECU_GENE [U4.71.03] appliqué à un calcul précédent.
Opérandes RESU/DEPL/VITE#
♦/ RESULTAT = tran
Concept de type tran_gene issu d’un calcul précédent avec DYNA_VIBRA.
/ I DEPL = do
Concept de type vect_asse_gene, déplacements généralisés initiaux.
I VITE = vo
Concept de type vect_asse_gene, vitesses généralisées initiales.
Opérandes INST_INIT / NUME_ORDRE#
◊ /INST_INIT = to
Instant du calcul précédent à extraire et à prendre comme état initial dans le cas d’une reprise. En l’absence de cet opérande, l’instant de reprise est pris égal au dernier instant de calcul précédent archivé.
/NUME_ORDRE = nuord
Désigne le numéro d’archivage du calcul précédent à extraire et à prendre comme état initial dans le cas d’une reprise.
Opérande CRITERE#
◊ CRITERE
Indique avec quelle précision la recherche de l’instant doit se faire:
“RELATIF” : intervalle de recherche [(1-prec).instant, (1+prec).instant]
“ABSOLU” : intervalle de recherche [instant-prec, instant+prec]
Le critère est “RELATIF” par défaut.
Opérande PRECISION#
◊ PRECISION = / 1.E-06 [DEFAUT]
/ prec [R8]
Indique avec quelle précision la recherche de l’instant doit se faire.
Description du chargement sous variables séparées : mot clé EXCIT#
◊ EXCIT
Mot clé définissant le chargement. Ce mot clé doit être répété autant de fois qu’il y a de vecteurs chargement généralisé \({f}_{i}\) . Le chargement total est la somme de ces vecteurs chargement. Ce mot-clé permet de définir le chargement sous a forme de vecteurs généralisés multipliés par des fonctions multiplicatrices.
Opérandes VECT_ASSE_GENE / NUME_ORDRE#
Le chargement est pris en compte sous forme de vecteur projeté sur la base modale EXCIT=_F(VECT_ASSE_GENE) ou sous forme de composante modale EXCIT=_F(NUME_MODE) ou les deux à la fois.
VECT_ASSE_GENE= v
Vecteur généralisé permettant de décrire la répartition spatiale du chargement.
Concept de type vect_asse_gene.
Les vecteurs généralisés doivent être établis par l’opérateur PROJ_VECT_BASE [U4.63.13] à partir de la base modale utilisée pour les matrices généralisées. Dans le cas d’un calcul par sous-structuration dynamique, les vecteurs généralisés doivent être établis par l’opérateur ASSE_VECT_GENE [U4.65.05] à partir de la numérotation généralisée utilisée pour les matrices généralisées.
/ NUME_ORDRE= nmordr
Numéro d’ordre du mode d’excitation de la structure (Attention! Il ne faut pas confondre le numéro d’ordre du mode – donné par le calcul modal dans l’ordre où ils ont été calculés – et le numéro du mode, intitulé dans Code_Aster NUME_MODE).
Opérande FONC_MULT / COEF_MULT#
♦ / FONC_MULT= f
Fonction du temps (fonction) permettant de décrire l’évolution temporelle du vecteur chargement.
/ COEF_MULT= a
Coefficient multiplicateur du vecteur généralisé (valeur réelle constante par rapport au temps).
Mot clé EXCIT_RESU#
Mot clé permettant de définir un chargement sous la forme d’une évolution temporelle généralisée, sans séparation de variables (cas le plus général). Cette évolution temporelle peut avoir été calculée à partir de l’opérateur PROJ_BASE, option RESU_GENE, qui réalise la projection d’un résultat dynamique transitoire (dyna_trans).
Mot-clé RESULTAT#
♦ / RESULTAT= resu_gene
Structure de données resu_gene définissant le chargement généralisé.
Opérande COEF_MULT#
◊ / COEF_MULT= f
Coefficient multiplicateur, vaut \(1.0\) par défaut.
Cas particulier de l’analyse sismique#
Prise en compte des modes négligés par correction statique : mots clés CORR_STAT, MODE_CORR et D_FONC_*#
Lors de l’analyse sismique d’une structure mono excitée, il est possible de prendre en compte, a posteriori, l’effet statique des modes négligés. Dans ce cas, lors du retour sur la base physique, les déplacements relatifs calculés (respectivement les vitesses et accélérations relatives) sont corrigés par un pseudo-mode.
On trouvera les détails de ce type de correction dans [R4.05.01].
À l’intérieur du mot clé facteur EXCIT, CORR_STAT=”OUI” permet la prise en compte des modes négligés par correction statique, il est alors obligatoire de renseigner les mots clés MODE_CORR, D_FONC_DT et D_FONC_DT2.
◊ MODE_CORR = modcor
Concept de type mult_elas produit par la macro-commande MACRO_ELAS_MULT [U4.51.02] ou mode_meca qui correspond à la réponse statique linéaire de la structure à un chargement unitaire de type force imposée (accélération uniforme) dans la direction du séisme considérée.
On note qu’il y a autant de cas de charge que de direction de séisme.
◊ EXCIT = _F( CORR_STAT )
Si MODE_CORR est présent, CORR_STAT=”OUI” permet de prendre en compte la contribution de la correction modale a posteriori pour chaque occurrence du mot clé EXCIT.
◊ EXCIT = _F( D_FONC_DTet D_FONC_DT2)
D_FONC_DT et D_FONC_DT2 sont respectivement les dérivées premières et dérivées secondes du temps de l’accélérogramme défini, dans chaque direction sismique considérée, par l’opérande FONC_MULT. Elles pondèrent la contribution de la correction modale a posteriori pour chaque occurrence du mot clé EXCIT afin d’obtenir respectivement les corrections de vitesse et d’accélération sur la base physique.
Remarques:
La prise en compte de la correction statique exclu t celle du multi-appuis.
Le concept mult_elas doit s’appuyer sur une numérotation des équations cohérentes(même profil et même option de renumérotation) avec celle du système résolu dans l’opérateur DYNA_VIBRA .
A la \(i\) ème occurrence du mot clé EXCIT correspond la \(i\) ème solution élastique de MODCOR .
Pour que la correction statique soit effectivement prise en compte lors du retour vers les coordonnées physiques dans l’opérateur REST_GENE_PHYS ou RECU_FONCTION il faut préciser CORR_STAT_=”OUI”.
Prise en compte du multi-appuis : mots clés MODE_STAT, MULTI_APPUI et ACCE, VITE, DEPL#
Dans le cas d’une structure multi-supportée, afin de restituer les grandeurs calculées dans le repère absolu ou prendre en compte des non linéarités localisées, il faut calculer la réponse généralisée en prenant en compte la composante d’entraînement.
Pour plus de détails, on se reportera à la référence [R4.05.01].
Les mots clés MODE_STAT, MULT_APPUI, ACCE, VITE, DEPL, DIRECTION et GROUP_NO) spécifiques à la prise en compte du caractère multi-supporté doivent être simultanément présents.
Un cham_no issu de la projection d’un CALC_CHAR_SEISME représente le vecteur d’excitation sur l’appui. Il ne doit pas être oublié, même si l’information peut paraître redondante avec la donnée de l’appui et de la direction de séisme.
◊ MODE_STAT = psi
Concept de type mode_meca produit par la commande MODE_STATIQUE [U4.52.14] qui correspond aux (3 ou 6) nb_supports modes statiques (où nb_supports est le nombre de supports qui subissent une accélération différente).
◊ EXCIT = _F( MULT_APPUI )
Si on calcule la réponse sismique d’une structure multi-supportée, MULT_APPUI= ’OUI’, on compare à chaque instant, le vecteur des déplacements absolus de chacun des points de choc considérés, afin de déterminer si il y a choc et de calculer les forces de choc correspondantes. Sinon, MULT_APPUI= ’NON’, on compare à chaque instant, le vecteur des déplacements relatifs de chacun des nœuds susceptibles de choquer.
◊ EXCIT = _F( / ◊ ACCE = ac,
◊ VITE = vi, ◊ DEPL = dp )
Noms des fonctions accélération (ACCE), vitesse (VITE) et déplacement (DEPL) imposées lors du calcul de la réponse sismique de structures multi-supportées.
Remarque:
Si la structure est mono-excitée, l’accélérogramme est défini par le mot clé FONC_MULT.
◊ EXCIT = _F( DIRECTION =(dx, dy, dz, drx, dry, drz))
Composantes du vecteur donnant la direction du séisme dans le repère global.
◊ EXCIT = _F( GROUP_NO = lgrno )
Liste des noms de groupe de nœuds correspondants aux appuis concernés où le séisme est imposé.
◊ EXCIT = _F( VECT_ASSE_GENE = v )
Vecteur projeté de l’excitation sismique (issu de CALC_CHAR_SEISME [U4.63.01])
Prise en compte d’un transitoire de vitesse de rotation#
Opérande VITESSE_VARIABLE#
Précise si la vitesse de rotation du rotor est variable en fonction du temps (VITESSE_VARIABLE = “OUI” pour les transitoires de vitesse) ou constante (VITESSE_VARIABLE = “NON”).
Opérandes VITE_ROTA, MATR_GYRO, ACCE_ROTA et MATR_RIGY#
Ces opérandes sont les paramètres définissant le transitoire de vitesse de rotation.
Si VITESSE_VARIABLE = “OUI”, alors il faut renseigner les paramètres suivants:
♦ VITE_ROTA = fonction donnant la loi de vitesse angulaire imposée au rotor
♦ MATR_GYRO = matrice d’amortissement gyroscopique
◊ ACCE_ROTA = fonction donnant la loi d’accélération angulaire imposée au rotor
◊ MATR_RIGY = matrice de raideur gyroscopique
Remarque:
Si ACCE_ROTA n’est pas fournie, elle est négligée (ie. pas de dérivation numérique à partir de VITE_ROTA).
Si VITESSE_VARIABLE = “NON”, il faut renseigner la valeur de la vitesse de rotation constante.
◊ VITE_ROTA = vitesse de rotation de l’arbre [par défaut 0.0]
Mot clé VERI_CHOC#
Mot clé qui permet d’évaluer a posteriori, l’aptitude de la base modale à représenter correctement les impacts.
Si VERI_CHOC est présent, on calcule en chaque nœud de choc et pour chaque mode, le taux de reconstitution de la solution statique: \({t}_{s}={K}_{\mathit{statique}}\sum_{i=1}^{n}\frac{{({}^{T}{\Phi}_{i}.{F}_{\mathit{impo}})}^{2}}{{k}_{i}}\) et, pour information, le taux de reconstitution de l’effort tranchant: \({t}_{N}=\sum_{i=1}^{n}\frac{{}^{T}{\Phi}_{i}.{F}_{\mathit{impo}}}{{k}_{i}}.({}^{T}{F}_{\mathit{impo}}.K.{\Phi}_{i})\) . On calcule ensuite les valeurs cumulées sur l’ensemble des modes qui constituent la base modale utilisée.
On vérifie que le rapport de la souplesse négligée (souplesse statique moins souplesse statique reconstituée) sur la souplesse de choc reste inférieur à la valeur donnée par l’opérande SEUIL (SEUIL vaut 0.5 par défaut) sinon:
si STOP_CRITERE= ‘OUI’ on arrête l’exécution du programme (c’est le cas par défaut);
si STOP_CRITERE= ‘NON’ on continue l’exécution du programme avec émission d’une alarme.
Remarques:
Cette fonctionnalitén’est disponible que pour des obstacles de type planou bi_plan.
Si le taux de reconstitution de la solution statique est inférieur à la valeur du seuil, on conseille à l’utilisateur de compléter la base modale par les modes locaux aux points de choc qui ont une souplesse locale importante.
La formule n’est pas applicable en cas de modes statiques (matrice de rigidité non inversible). Le calcul se poursuit alors sans vérification des critères de choc et l’utilisateur en est averti.
Mot clé COMPORTEMENT#
Ce mot clé facteur permet de définir un comportement non-linéaire localisé (appliqué sur un nœud). Plusieurs types de comportement sont disponibles.
Non linéarités localisées de type choc et frottement : DIS_CHOC#
◊ RELATION = 'DIS_CHOC
Ce mot clé est utilisé pour l’étude de la réponse de structures (généralement élancées) dont les déplacements sont limités en un (ou plusieurs) point(s) -précisés a priori par l’utilisateur- par la présence d’un obstacle (les différents types d’obstacles disponibles sont décrit dans la documentation [U4.44.21] de l’opérateur DEFI_OBSTACLE), d’une autre structure antagoniste.
Opérande INTITULE#
◊ INTITULE= int
Intitulé (huit caractères au maximum) permettant de nommer la non-linéarité. Si rien n’est précisé par l’utilisateur, l’intitulé est le nom du nœud du GROUP_NO_1.
Opérandes GROUP_NO_1 / GROUP_NO_2 . / GROUP_MA#
♦ GROUP_NO_1
Nom du groupe de nœud de la structure sur lequel porte la condition de non-linéarité.
Dans le cas d’un calcul non-linéaire par sous-structuration dynamique, on indique sous ce mot clé le nœud de choc appartenant à la première sous-structure (les différentes sous‑structures n’appartiennent pas au même maillage).
◊ GROUP_NO_2
Nom du groupe de nœud de la seconde structure sur lequel porte la condition de non‑linéarité. Cette opérande est spécifique à la définition d’un contact entre deux structures mobiles.
Dans le cas d’un calcul non-linéaire par sous-structuration dynamique, on précise le nœud de choc coïncidant avec le nœud indiqué dans GROUP_NO_1, mais appartenant à la deuxième sous-structure.
Remarque:
On vérifie que les groupes de nœuds contiennent bien un et un seul nœud.
♦ GROUP_MA
On peut aussi entrer les nœuds de chocs en vis à vis sous la forme de mailles SEG2 dessinées dans le maillage. Ainsi on conserve une même façon de décrire les chocs que pour DYNA_NON_LINE avec les éléments discrets de choc (DIS_CHOC). On peut entrer une liste de GROUP_MA.
Opérande OBSTACLE#
♦ OBSTACLE= obs
Nom du concept de type obstacle définissant la géométrie d’un obstacle indéformable ou la forme enveloppe du jeu entre deux structures antagonistes. Il est produit par l’opérateur DEFI_OBSTACLE [U4.44.21].
Opérande NORM_OBST#
♦ NORM_OBST= nor
Liste de 3 réels définissant la normale au plan de coupe de l’obstacle, c’est-à-dire le vecteur \({X}_{\mathit{loc}}\) tel que défini dans la documentation de l’opérateur DEFI_OBSTACLE [U4.44.21]. On conseille que \({X}_{\mathit{loc}}\) soit la direction de la fibre neutre ou d’une génératrice de la structure étudiée.
Remarques :
En dépit du nom donné à l’opérande, NORM_OBST n’est pas un vecteur normal à l’obstacle, mais normal à la direction de contact pour les obstacles PLAN ou BI_PLAN, ou aux directions de contact pour les autres types d’obstacles ;
Dans le cas d’un obstacle de type BI_PLAN_Y ou BI_PLAN_Z, il est recommandé de préciser l’angle de vrille (opérande ANGL_VRIL), ou de définir le vecteur \({X}_{\mathit{loc}}\) dans le plan formé par le vecteur défini par les noeuds des groupes GROUP_NO_1 et GROUP_NO_2 et le vecteur normal à la direction de contact souhaitée. cf. opérande ANGL_VRIL.
Opérande ORIG_OBST#
◊ ORIG_OBST= ori
Liste de 3 réels définissant la position de l’origine de l’obstacle dans le repère global (mot clé obligatoire dans le cas de chocs entre une structure mobile et une paroi fixe). Dans le cas de chocs entre deux structures mobiles, le code considère par défaut que l’origine est située au milieu des deux nœuds de choc GROUP_NO_1 et GROUP_NO_2.
Opérande JEU#
◊ JEU= jeu
Dans le cas d’un choc entre une structure mobile et un obstacle indéformable, l’opérande JEU représente:
la demi-distance inter-plans pour des obstacles de type PLAN_Y et PLAN_Z
le rayon de l’obstacle circulaire pour un obstacle de type CERCLE
Ce mot clé est inutilisé dans le cas d’obstacles discrétisés par segments de type DISCRET.
Remarque :
L’obstacle de type PLAN_Y ou PLAN_Z comporte en fait deux obstacles plans. Ainsi dans le cas où l’utilisateur souhaite modéliser le choc sur un plan unique, pour ne pas être gêné par le rebond de la structure étudiée sur le plan symétrique, on conseille à l’utilisateur de le repousser très loin (cf. figure ci-dessous, on représente le jeu réel entre la structure étudiée et l’obstacle).
Fig. 114 Système masse-ressort impactant une paroi fixe#
Remarque :
Le mot-clé JEU n’est pas utilisé dans le cas de choc entre structures mobiles.
Les différents cas de jeux sont représentés dans la documentation de DEFI_OBSTACLE [U4.44.21].
Opérande ANGL_VRIL#
◊ ANGL_VRIL= gamma
\(\gamma\) , angle en degrés complétant la définition de la position angulaire du repère local dans le repère global.
Par convention, la normale au plan de coupe de l’obstacle, NORM_OBST, définit l’axe \({X}_{\mathit{loc}}\) du repère local. Pour les obstacles de type PLAN ou BI_PLAN, cette normale n’est pas unique. Tout vecteur compris dans le plan de l’obstacle est un vecteur normal à un des plans de coupe de l’obstacle. Pour tous les autres obstacles, cette orientation est unique.
On passe du repère global \((X,Y,Z)\) au repère local du plan de l’obstacle \(({X}_{\mathit{loc}}, {Y}_{\mathit{loc}}, {Z}_{\mathit{loc}})\) par un produit de trois rotations suivant les angles d’Euler :
Une première rotation \(R_1(\alpha, Z)\) d’angle \(\alpha\) autour de l’axe \(Z\) du repère global ;
Une deuxième rotation \(R_2(\beta, Y_1)\) d’angle \(\beta\) autour du vecteur \({Y}_{1}\), image de \(Y\) par \(R_1(\alpha, Z)\);
Une troisième rotation \(R_3(\gamma, X_2)\) d’angle \(\gamma\) autour du vecteur \({X}_{2}\), image de \(X_1\) par \(R_2(\beta, Y_1)\).
La première figure ci-dessous donne la position du plan d’un obstacle de type PLAN_Z (ou BI_PLAN_Z) dans le repère global \((X, Y, Z)\), et le repère local \(({X}_{\mathit{loc}}, {Y}_{\mathit{loc}}, {Z}_{\mathit{loc}})\) associé. La deuxième figure ci-dessous décrit l’ensemble des rotations, avec leurs paramètres, permettant le passage du repère global au repère local.
Fig. 115 Position de l’obstacle et son repère local dans le repère global, et vue de la composition complète des rotations.#
Fig. 116 Décomposition du mouvement complet en rotations élémentaires paramétrées par les angles d’Euler.#
Les angles \(\alpha\) et \(\beta\) sont déterminés automatiquement à partir de la normale à l’obstacle \({X}_{\mathit{loc}}\). \(\alpha\) correspond à l’angle formé par \(X\) et \(X_1\), où \(X_1\) est la projection de \({X}_{\mathit{loc}}\) dans le plan \((X, Y)\). \(\beta\) est l’angle formé par \(X_1\) et \(X_{\mathit{loc}}\). Si \(X_{\mathit{loc}}\) est colinéaire à \(Z\), alors \(\alpha\) est pris égal à 0.
La seule donnée de \(X_{\mathit{loc}}\) ne permet pas de positionner complètement le repère local, il faut alors définir \(\gamma\), appelé l’angle de vrille, pour positionner complètement l’obstacle :
Pour tous les types d’obstacles, à l’exception des obstacles de type BI_PLAN, la valeur par défaut de \(\gamma\) est zéro. Il est alors indispensable de vérifier que cette valeur est bien celle attendue, ou, sinon, d’indiquer la valeur souhaitée ;
Dans le cas de chocs entre structures mobiles avec des obstacles de type BI_PLAN, si l’utilisateur ne précise rien, l’angle de vrille est calculé par le code. On détaille dans la suite la démarche de calcul de l’angle de vrille pour le cas des obstacles de type BI_PLAN.
Si on note \({N_1}{N_2}\) le vecteur défini par les noeuds de GROUP_NO_1 et GROUP_NO_2, l’angle de vrille est calculé à partir des directions des vecteurs \({Y}_{\mathit{loc}}\) et \({Z}_{\mathit{loc}}\), où \({Y}_{\mathit{loc}}\) est obtenu par projection :
du vecteur \({N_1}{N_2}\) sur le plan normal à \({X}_{\mathit{loc}}\) pour le cas d’un obstacle BI_PLAN_Y;
du vecteur \({N_1}{N_2} \wedge {X}_{\mathit{loc}}\) sur le plan normal à \({X}_{\mathit{loc}}\) pour le cas d’un obstacle BI_PLAN_Z,
et \({Z}_{\mathit{loc}}\) complète le trièdre, de sorte que (\({X}_{\mathit{loc}}\), \({Y}_{\mathit{loc}}\), \({Z}_{\mathit{loc}}\)) soit direct.
Si on ne fait pas attention à ce point, et qu’on ne spécifie pas l’opérande ANGL_VRIL, il est possible d’obtenir des résultats surprenants, au premier abord. Une solution permettant de se prémunir des résultats de ce calcul consiste à faire en sorte que la direction normale au contact (\({Y}_{\mathit{loc}}\) pour un obstacle de type BI_PLAN_Y, ou \({Z}_{\mathit{loc}}\) pour un obstacle de type BI_PLAN_Z) se trouve dans le plan formé par les vecteurs \({X}_{\mathit{loc}}\) et \({N}_{1}{N}_{2}\). Cela revient à choisir \({X}_{\mathit{loc}}\) tel que :
\({X}_{\mathit{loc}}\) est dans le plan de l’obstacle ;
\({X}_{\mathit{loc}}\) est dans le plan formé par le vecteur \({N_1}{N_2}\) et le vecteur normal à la direction de contact (\({Y}_{\mathit{loc}}\) ou \({Z}_{\mathit{loc}}\), selon le type d’obstacle choisi).
Ce choix de \({X}_{\mathit{loc}}\), compte tenu de la démarche de calcul de l’angle de vrille, garantit la bonne orientation des vecteurs \({Y}_{\mathit{loc}}\) et \({Z}_{\mathit{loc}}\), quel que soit le type d’obstacle choisi.
Dans tous les autres cas de choix de \({X}_{\mathit{loc}}\), on recommande vivement de préciser l’angle de vrille, pour éviter les comportements inattendus. On illustre ce besoin à l’aide du cas simple suivant.
Le modèle est constitué de deux poutres, orientées par l’axe \(Y\) du repère global, qui peuvent s’entre choquer au niveau des noeuds \({N}_{1}\) et \({N}_{2}\) selon la direction portée par l’axe \(Z\) du repère global. Ces deux poutres sont dans un plan parallèle au plan \((Y, Z)\), mais le vecteur \({N_1}{N_2}\) n’est pas colinéaire à \(Z\). La définition d’un obstacle de type BI_PLAN associé est représenté sur la figure ci-dessous.
Fig. 117 Représentation du cas de contact souhaité.#
Pour obtenir ce résultat, on souhaite utiliser un obstacle de type BI_PLAN_Z. Par définition, la direction \({X}_{\mathit{loc}}\) doit être normale au plan de coupe de l’obstacle (et donc, ici, contenue dans les plans définissant les obstacles). Il est possible de choisir \({X}_{\mathit{loc}}\) comme étant la direction \(X\) du repère global (cas (a) sur la figure ci-dessous, avec NORM_OBST = (1, 0, 0)), mais aussi comme étant la direction \({Y}_{\mathit{loc}}\) du repère global (cas (b) sur cette même figure, avec NORM_OBST = (0, 1, 0)). Tout autre choix de vecteur dans le plan (\({X}\), \({Y}\)) est possible. En revanche, seul le cas (b) correspond à la préconisation formulée.
Fig. 118 Représentation de 2 choix possibles pour** \({X}_{\mathit{loc}}\) (opérande NORM_OBST), et de la direction de contact \({Z}_{\mathit{loc}}\) souhaitée.#
La figure ci-dessous représente les plans associés à cet obstacle dans les cas (a) et (b) lorsque l’opérande ANGL_VRIL n’est pas renseigné, et que c’est le code qui le calcule. Il apparaît que le cas (a) ne correspond pas à ce qui est souhaité (comme tous les cas où \({X}_{\mathit{loc}}\) n’est pas colinéaire à \(Y\)), puisque le vecteur \({Z}_{\mathit{loc}}\) obtenu n’est pas colinéaire au vecteur \(Z\), souhaité pour définir la direction de contact. \({Y}_{\mathit{loc}}\), en revanche, correspond bien à la direction obtenue par projection du vecteur \({N_1}{N_2} \wedge {X}_{\mathit{loc}}\) sur le plan normal à \({X}_{\mathit{loc}}\), et \({Z}_{\mathit{loc}}\) complète le trièdre. Pour obtenir le résultat souhaité, dans ce cas, il faut préciser ANGL_VRIL = 0.
Dans le cas (b), en revanche, puisque le vecteur \({X}_{\mathit{loc}}\) est bien dans le plan formé par le vecteur \({N_1}{N_2}\) et la direction de contact souhaitée, on obtient bien le résultat voulu sans avoir besoin de préciser l’opérande ANGL_VRIL.
Fig. 119 Résultats obtenus dans les deux cas si ANGL_VRIL n’est pas renseigné.#
Opérandes DIST_1/DIST_2#
◊ DIST_1= dist1
Distance caractéristique de matière entourant GROUP_NO_1: no1.
Opérande spécifique au contact entre deux structures mobiles.
◊ DIST_2= dist2
Distance caractéristique de matière entourant GROUP_NO_2: no2.
Opérande spécifique au contact entre deux structures mobiles.
Remarques:
DIST_1et DIST_2sont définies au sens des normales sortantes des deux solides en vis‑à-vis (DIST_1et DIST_2sont positives car elles représentent l’épaisseur des structures étudiées).
Du fait du calcul de la distance normale de choc, la somme de DIST_1et de DIST_2 doit être suffisamment grande par rapport à l’amplitude supposée du déplacement relatif des nœuds de chocs (cf. [R5.06.03]).
Opérandes SOUS_STRUC_1 / SOUS_STRUC_2#
◊ SOUS_STRUC_1= ss1
Nom de la sous-structure qui contient le nœud de choc renseignant le mot clé GROUP_NO_1.
◊ SOUS_STRUC_2= ss2
Nom de la sous-structure qui contient le nœud de choc renseignant le mot clé GROUP_NO_2.
Opérande REPERE#
◊ REPERE = rep
Précise le repère dans lequel la position de l’obstacle est définie.
/ “GLOBAL”
La position absolue de l’obstacle est définie indépendamment des rotations et translations auxquelles sont soumises les différentes sous-structures.
/ nom_sst
Nom d’une sous-structure.
La position et la normale de l’obstacle sont déterminées dans le repère utilisé pour définir les coordonnées des nœuds de la sous-structure nom_sst, la position et la normale finales de l’obstacle étant le résultat de la rotation et de la translation auxquelles est soumise la sous‑structure.
Opérande RIGI_NOR#
♦ RIGI_NOR= kn
Valeur de la rigidité normale de choc (unité \(N/m\) en USI).
Opérande AMOR_NOR#
◊ AMOR_NOR= cn
Valeur de l’amortissement normal de choc (unité \(Nm/s\) en USI).
Opérande RIGI_TAN#
♦ RIGI_TAN= kt
Valeur de la rigidité tangentielle de choc (unité \(N/m\) en USI).
Opérande AMOR_TAN#
◊ AMOR_TAN= ct
Valeur de l’amortissement tangentiel de choc (unité \(Nm/s\) en USI).
Remarque:
Si une raideur \({k}_{t}\) est spécifiée et que le mot clé AMOR_TANest absent, le code calcule un amortissement optimisé de façon à minimiser les oscillations résiduelles en adhérence selon la formule:
où \(i\) est l’indice du mode prépondérant à la direction tangentielle dans la réponse de la structure (la plus grande masse modale normalisée par le déplacement tangentiel).
Opérande FROTTEMENT#
◊ FROTTEMENT= / 'NON'
La condition de contact est sans frottement.
/ “COULOMB” ♦ COULOMB = mu
Valeur du coefficient de frottement (sans dimension).
/ “COULOMB_STAT_DYNA” ♦ COULOMB_STAT = mus
Valeur du coefficient d’adhérence (sans dimension).
♦ COULOMB_DYNA = mud
Valeur du coefficient de glissement (sans dimension).
Opérande UNIDIRECTIONNEL#
◊ UNIDIRECTIONNEL = / “NON”, [DEFAUT]
/ “OUI”,
Activation du frottement unidirectionnel permettant de définir un coefficient de frottement non isotrope dans le plan de l’obstacle. Cette option est utilisable aussi bien avec le frottement de type “COULOMB” qu’avec le frottement “COULOMB_STAT_DYNA”. Elleest utilisée pour modéliser le roulement etle frottement d’un galet sur un rail, tout en autorisant le soulèvement.
Avec un frottement de type “COULOMB”:
Le coefficient de frottement vaut 0.suivant l’axe renseigné dans NORM_OBST et mudans la direction perpendiculaire (cf. [R5.06.03]).
Avec un frottement de type “COULOMB_STAT_DYNA”:
Le coefficient d’adhérence vaut 0.suivant l’axe renseigné dans NORM_OBST et musdans la direction perpendiculaire. Le coefficient de glissement vaut 0.suivant l’axe renseigné dans NORM_OBST et muddans la direction perpendiculaire.
Non linéarités localisées de rotor fissuré : ROTOR_FISS#
Les opérandes suivants sont spécifiques au calcul transitoire avec non-linéarité localisée de type «rotor fissuré» pour les calculs de ligne d’arbre modélisée en 1D (poutre). La fissure est considérée totalement incluse dans une section du rotor. Elle est délimitée par deux nœuds distincts mais de coordonnées confondues, l’un reliée à la partie gauche de la ligne d’arbre, l’autre à la partie droite. Ils représentent respectivement la lèvre gauche et la lèvre droite de la fissure.
Le comportement de la fissure est donné par une loi de raideur de fissure et sa dérivée. Cette loi est déterminée par ailleurs par des calculs 3D en quasi-statique. Elle ne dépend pas de la géométrie du rotor mais uniquement de la forme de la fissure et d’un coefficient de dimension.
◊ RELATION = “ROTOR_FISS”
/ ♦ GROUP_NO_G = groupe de nœud nommant la lèvre gauche de la fissure
♦ GROUP_NO_D = groupe de nœud nommant la lèvre droite de la fissure
♦ ANGL_INIT = angle initial du fond de fissure par rapport à sa définition dans la loi de comportement de fissure [par défaut 0.0]
◊ ANGL_ROTA = fonction donnant la loi imposée de position angulaire du fond de fissure par rapport à sa définition dans la loi de comportement de fissure (transitoires de vitesse)
♦ K_PHI = loi de comportement en raideur de la fissure
♦ DK_DPHI = dérivée de la loi de comportement en raideur
Orientation de l’axe du rotor :
Pour respecter le sens de rotation trigonométrique, il est important de bien orienter le rotor: l’axe du rotor est automatiquement orienté par la fissure, en allant du bord gauche vers le bord droite de la fissure.
Non-linéarité localisée : ANTI_SISM#
◊ RELATION = “ANTI_SISM”
Cette relation ANTI_SISM est incompatible avec un calcul par sous-structuration dynamique. Elle permet de calculer la force non linéaire qui existe si un dispositif anti-sismique est placé entre les deux nœuds antagonistes dont les noms sont précisés par les mots clés (GROUP_NO_1 et GROUP_NO_2):
◊ RIGI_K1, RIGI_K2, SEUIL_FX, C, PUIS_ALPHA et DX_MAX
Paramètres de la force due à la présence d’un dispositif anti-sismique.
A titre d’exemple, les valeurs des paramètres pour un dispositif anti-sismique de type JARRET sont:
\(\mathit{K1}=6.E+06N/m\) , \(\mathit{K2}=0.53E+06N/m\) , \(\mathit{Py}=1200.\) , \(C=0.07E+05\mathit{Nm}/s\) , \(alpha=0.2\) et \(\mathit{xmax}=0.03m\) (si le problème est posé en USI).
Non-linéarité : DIS_VISC#
C’est un comportement viscoélastique non linéaire entre deux nœuds, cf. [R5.03.17]. Ce comportement n’affecte que le degré de liberté \(\mathit{DX}\) local de l’élément. La direction \(x\) locale de l’élément va du nœud 1 au nœud 2.
Remarques:
C’est un comportement viscoélastique non linéaire entre deux nœuds, il n’y a donc pas d’élément finis entre les nœuds concernés (juste une relation de comportement). Lors du calcul de la base modale réduite, il peut être judicieux de définir un élément avec une raideur élastique correspondant à la tangente au comportement du dispositif [R5.03.17] .
Les résultats concernant l’effort, les déplacements visqueux et relatifs entre les deux nœuds, ainsi que la dissipation du dispositif non-linéaire peuvent être sauvegardés dans un fichier directement exploitable par les commandes de Code_Aster. La définition du fichier se fait par le mot-clé simple UNITE_DIS_VISC qui est dans le mot-clé facteur IMPRESSION de la commande.
Fig. 120 Schéma du dispositif.#
Syntaxe#
◊ RELATION = “DIS_VISC”
♦ GROUP_NO_1 =grno1, [group_no]
♦ GROUP_NO_2 =grno2, [group_no]
♦ /K1 =k1, [R]
- /UNSUR_K1
=usk1, [R]
♦ /K2 =k2, [R]
- /UNSUR_K2
=usk2, [R]
♦ /K3 =k3, [R]
- /UNSUR_K3
=usk3, [R]
♦ C =c, [R]
♦ PUIS_ALPHA =/0.5 [defaut]
/alpha, [R]
♦ ITER_INTE_MAXI =/20 [defaut]
- /iter
[I]
♦ RESI_INTE_RELA =/1.0E-06 [defaut]
- /resi
[R]
Opérandes liés à la position du dispositif#
♦ GROUP_NO_1
♦ GROUP_NO_2
Nom des groupes de nœud de la structure entre lesquels le dispositif non-linéaire est placé. Le groupe de nœud ne doit contenir qu’un seul nœud.
Lors du calcul, il est nécessaire de connaître la direction du dispositif non-linéaire car il ne fonctionne que dans son axe. Il faut donc que la distance entre les deux nœuds soit non nulle.
Opérandes liés au comportement#
Le comportement DIS_VISCest un comportement rhéologique viscoélastique non linéaire, de type Zenerétendu, permettant de schématiser le comportement d’un amortisseur uni-axial, entre deux nœuds.
Pour la direction locale \(x\) (et seulement celle-là) du dispositif, on fournit cinq coefficients. Leurs unités doivent être en accord avec l’unité des efforts, l’unité des longueurs et l’unité de temps du problème:
K1: raideur élastique de l’élément 1 du modèle rhéologique,
K2: raideur élastique de l’élément 2 du modèle rhéologique,
K3: raideur élastique de l’élément 3 du modèle rhéologique,
UNSUR_K1: souplesse élastique de l’élément 1 du modèle rhéologique,
UNSUR_K2: souplesse élastique de l’élément 2 du modèle rhéologique,
UNSUR_K3: souplesse élastique de l’élément 3 du modèle rhéologique,
PUIS_ALPHA:puissance du comportement visqueux de l’élément \(\alpha\) ,
C: coefficient du comportement visqueux de l’élément.
Il existe des conditions à respecter sur les valeurs des coefficients pour que la tangente soit toujours définie:
\(\mathit{k1}\ge {10}^{-8}\) \(\mathit{usk1}\ge 0\) \(\mathit{k3}\ge {10}^{-8}\) \(\mathit{usk3}\ge 0\) \(\mathit{usk2}\ge {10}^{-8}\) \(\mathit{k2}\ge 0\) \(C\ge {10}^{-8}\) \({10}^{-8}\le \alpha \le 1\)
On ne peut donc pas avoir à la fois \(\mathit{usk1}=0\) , \(\mathit{usk3}=0\) et \(\mathit{k2}=0\) c’est-à-dire le cas de l’amortisseur seul.
Opérandes liés à la convergence du comportement du dispositif#
♦ ITER_INTE_MAXI =/20 [defaut]
- /iter
[I]
♦ RESI_INTE_RELA =/1.0E-06 [defaut]
- /resi
[R]
Ces opérandes ont la même signification que lorsqu’ils sont utilisés avec la commande STAT_NON_LINE/COMPORTEMENT [U4.51.11].
La relation de comportement DIS_VISCnécessite de résoudre un système non linéaire par une méthode de Runge-Kutta d’ordre 5 à pas adaptatif. Le contrôle de l’algorithme (nombre d’itération et résidu) sont utilisés pour tester la convergence et adapter le pas si besoin.
Non-linéarité : DIS_ECRO_TRAC#
Le comportement DIS_ECRO_TRAC est un comportement non linéaire, permettant de schématiser le comportement d’un dispositif uniaxial, suivant l’axe local \(x\) ou dans le plan tangent \(yz\) .
Remarque:
C’est un comportement non linéaire entre deux nœuds, il n’y a donc pas d’élément finis entre les nœuds concernés (juste une relation de comportement). Lors du calcul de la base modale réduite, il peut être judicieux de définir un élément avec une raideur élastique correspondant à la tangente au comportement du dispositif [R5.03.17] .
Le comportement non-linéaire est donné par une courbe \(F=\mathit{fonction}(\Delta U)\) :
\(\Delta u\) représente le déplacement relatif des 2 nœuds dans le repère local de l’élément.
\(F\) représente l’effort exprimé dans le repère local de l’élément.
Syntaxe#
◊ RELATION = “DIS_ECRO_TRAC”
♦ GROUP_NO_1 =grno1, [group_no]
♦ GROUP_NO_2 =grno2, [group_no]
♦ / FX =fx, [fonction]
/ FTAN =ftan, [fonction]
# si la fonction FTAN est donnée
♦ ECROUISSAGE = | “ISOTROPE”,
“CINEMATIQUE”♦ ITER_INTE_MAXI =/20 [defaut]
- /iter
[I]
♦ RESI_INTE_RELA =/1.0E-06 [defaut]
- /resi
[R]
Opérandes liés à la position du dispositif#
♦ GROUP_NO_1
♦ GROUP_NO_2
Nom des groupes de nœud de la structure entre lesquels le dispositif non-linéaire est placé. Le groupe de nœud ne doit contenir qu’un seul nœud.
Lors du calcul, il est nécessaire de connaître la direction du dispositif non-linéaire car il ne fonctionne que dans son axe. Il faut donc que la distance entre les deux nœuds soit non nulle.
Opérandes liés au comportement : FX ou FTAN#
La seule donnée nécessaire est la fonction décrivant le comportement non-linéaire. Cette fonction doit respecter les critères suivant:
C’est une fonction au sens de code_aster: définie avec l’opérateur DEFI_FONCTION,
Les interpolations sur les axes des abscisses et des ordonnées sont linéaires,
Le nom de l’abscisse lors de la définition de la fonction est DX ou DTAN,
Les prolongements à gauche et à droite de la fonction sont exclus,
La fonction doit être définie par au moins 3 points,
Le premier point est \((\mathrm{0.0,}0.0)\) et doit être donné,
La fonction doit être strictement croissante.
La dérivée de la fonction doit être inférieure ou égale à sa dérivée au point \((\mathrm{0.0,0}.0)\) .
Exemples de définition de la fonction FX:
LesX = (0.0 , 0.2 , 0.3 , 0.50)
LesY = (0.0 , 500.0 , 800.0 , 900.0)
fctsy1 = DEFI_FONCTION(NOM_PARA=”DX” ,
ABSCISSE = LesX,
ORDONNEE = LesY,
)
fctsy2 = DEFI_FONCTION(NOM_PARA=”DX” ,
VALE = ( 0.0, 0.0, 0.2, 500.0, 0.3, 800.0, 0.50 , 900.0 ) ,
)
Exemples de définition de la fonction FTAN:
LesX = (0.0 , 0.2 , 0.3)
LesY = (0.0 , 500.0 , 800.0)
fctsy1 = DEFI_FONCTION(NOM_PARA=”DTAN” ,
ABSCISSE = LesX,
ORDONNEE = LesY,
)
fctsy2 = DEFI_FONCTION(NOM_PARA=”DTAN” ,
VALE = ( 0.0, 0.0, 0.2, 500.0, 0.3, 800.0 ) ,
)
Les deux premiers points de la fonction permettent de définir la pente élastique au comportement. Les unités des abscisses et des ordonnées doivent être cohérentes avec celles du problème:
L’unité des abscisses doit être homogène à des déplacements,
L’unité de la fonction doit être homogène à des efforts.
Opérandes liés à la convergence du comportement du dispositif#
♦ ITER_INTE_MAXI = / 20 [defaut]
/ iter [I]
♦ RESI_INTE_RELA = / 1.0E-06 [defaut]
/ resi [R]
Ces opérandes ont la même signification que lorsqu’ils sont utilisés avec la commande STAT_NON_LINE/COMPORTEMENT [U4.51.11].
La relation de comportement DIS_ECRO_TRAC nécessite de résoudre un système non linéaire par une méthode de Runge-Kutta d’ordre 5 à pas adaptatif. Le contrôle de l’algorithme (nombre d’itérations et résidu) sont utilisés pour tester la convergence et adapter le pas si besoin.
Non-linéarité : CHOC_ELAS_TRAC#
Le comportement CHOC_ELAS_TRAC est un comportement élastique non linéaire, permettant de schématiser le comportement d’un dispositif uniaxial, suivant l’axe local \(x\)
Remarque:
C’est un comportement non linéaire entre deux nœuds, il n’y a donc pas d’élément finis entre les nœuds concernés (juste une relation de comportement). Lors du calcul de la base modale réduite, il peut être judicieux de définir un élément avec une raideur élastique correspondant à la tangente au comportement du dispositif [R5.03.17] .
Le comportement élastique non-linéaire est donné par une courbe \(F=\mathit{fonction}(\Delta U)\) :
\(\Delta u\) représente le déplacement relatif des 2 nœuds dans le repère local de l’élément.
\(F\) représente l’effort exprimé dans le repère local de l’élément.
Syntaxe#
◊ RELATION = “CHOC_ELAS_TRAC”
♦ GROUP_NO_1 = grno1, [group_no]
♦ GROUP_NO_2 = grno2, [group_no]
♦ FX = fx, [fonction]
◊ DIST_1 = dist1, [R]
◊ DIST_2 = dist2, [R]
Opérandes GROUP_NO_1/GROUP_NO_2#
♦ GROUP_NO_1
♦ GROUP_NO_2
Nom des groupes de nœud de la structure entre lesquels le dispositif non-linéaire est placé. Le groupe de nœud ne doit contenir qu’un seul nœud.
Lors du calcul, il est nécessaire de connaître la direction du dispositif non-linéaire car il ne fonctionne que dans son axe.
Opérandes DIST_1/DIST_2#
◊ DIST_1 = dist1
Distance caractéristique de matière entourant GROUP_NO_1: no1.
Opérande spécifique au contact entre deux structures mobiles.
◊ DIST_2 = dist2
Distance caractéristique de matière entourant GROUP_NO_2: no2.
Opérande spécifique au contact entre deux structures mobiles.
Remarques: DIST_1et DIST_2 sont définies au sens des normales sortantes des deux solides en vis‑à-vis (DIST_1et DIST_2sont positives car elles représentent l’épaisseur des structures étudiées).
Opérande liés au comportement : FX#
La seule donnée nécessaire est la fonction décrivant le comportement non-linéaire. Cette fonction doit respecter les critères suivant:
C’est une fonction au sens de code_aster: définie avec l’opérateur DEFI_FONCTION,
Les interpolations sur les axes des abscisses et des ordonnées sont linéaires,
Le nom de l’abscisse lors de la définition de la fonction est DX.
Le prolongement à gauche de la fonction est exclu,
Le prolongements à droite de la fonction est exclu ou linéaire,
La fonction doit être définie par au moins 2 points,
Le premier point est \((\mathrm{0.0,}0.0)\) et doit être donné,
La fonction doit être strictement croissante.
Les unités des abscisses et des ordonnées doivent être cohérentes avec celles du problème:
L’unité des abscisses doit être homogène à des déplacements,
L’unité de la fonction doit être homogène à des efforts.
Non-linéarité : FLAMBAGE#
◊ RELATION = 'FLAMBAGE'
Cette relation est utilisée pour la détection de flambage éventuel et pour l’évaluation de la déformation résiduelle d’un élément lors d’un choc entre deux structures mobiles ou entre une structure mobile et une paroi fixe. La force de réaction lors d’un choc avec prise en compte du flambage est donnée par trois fonctions de l’enfoncement (définies par l’utilisateur), à savoir l’effort seuil, la rigidité et l’amortissement de flambage.
On considère qu’il y a flambage si la force de réaction \(F\) atteint la valeur limite \(F_{\mathrm{seuil}}\) définie par l’utilisateur. À chaque instant, si le choc est détecté, l’effort est donné par:
où \(u\) désigne la compression entre les deux nœuds, \(v\) la vitesse relative des nœuds, et \(u_{\max}\) la compression maximale atteinte au cours du calcul, définie par \(u_{\max}(t) = \max_{\tau \le t}u(\tau)\) pour tout instant \(t\). \(F_{\mathrm{seuil}}\), \(K\) et \(C\) désignent respectivement l’effort seuil, la rigidité et l’amortissement de flambage.
Seules les opérandes spécifiques au mot clé FLAMBAGE sont détaillées. Les autres mots clés permettent de définir les lieux de choc et sont identiques aux opérandes pour la relation DIS_CHOC (cf. § 5.11.1 ).
♦ FX = fx, [fonction]
♦ RIGI_NOR = rigi_nor, [fonction]
♦ AMOR_NOR = amor_nor, [fonction]
La description du comportement non-linéaire est donnée par trois fonctions, à savoir l’effort seuil (FX), la rigidité (RIGI_NOR) et l’amortissement (AMOR_NOR) de flambage. Chaque fonction doit respecter les critères suivant:
C’est une fonction au sens de code_aster: définie avec l’opérateur DEFI_FONCTION,
Les interpolations sur les axes des abscisses et des ordonnées sont linéaires,
Le nom de l’abscisse lors de la définition de la fonction est DX.
La fonction doit être définie par au moins 2 points,
Les abscisses de la fonction doivent être strictement croissantes.
Les unités des abscisses et des ordonnées doivent être cohérentes avec celles du problème:
L’unité des abscisses doit être homogène à des déplacements,
L’unité de la fonction doit être homogène à des efforts pour FX, à des rigidités pour RIGI_NOR, et à des amortissemnts pour AMOR_NOR.
◊ CRIT_AMOR=| 'INCLUS', [DEFAUT]
| 'EXCLUS'
Le mot clé CRIT_AMOR permetde spécifier si le critère de flambage est comparé à l’effort total de choc, ou uniquement à la part liée à la raideur de choc. Si CRIT_AMOR=”INCLUS”, le critère de flambage \(F_{\mathrm{seuil}}\) est comparé à l’effort total de choc \(K(u_{\max})\times u+C(u_{\max})\times v\) . Dans ce cas l’effort total de choc ne pourra jamais dépasser le critère de flambage. Si CRIT_AMOR=”EXCLUS” l’effort visqueux n’est pas inclus lors de la comparaison au critère. Le critère de flambage est comparé à l’effort généré par la raideur et l’enfoncement \(K(u_{\max})\times u\) . Dans ce cas l’effort total de choc pourra être supérieur au critère de flambage.
Non-linéarité : RELA_EFFO_DEPL#
◊ RELATION = 'RELA_EFFO_DEPL'
Cette relation permet de définir une relation force-déplacement ou moment‑rotation sur un degré de liberté donné sous la forme d’une courbe non linéaire.
Opérande GROUP_NO#
♦ GROUP_NO = grno
Nœud de la structure sur lequel porte la relation.
Opérande SOUS_STRUC#
◊ SOUS_STRUC= ss
Nom de la sous-structure contenant le nœud renseignant l’opérande GROUP_NO.
Opérande NOM_CMP#
◊ NOM_CMP= nomcmp
Nom de la composante du nœud de la structure sur laquelle porte la relation.
Opérande FONCTION#
♦ FONCTION= f
Nom de la fonction non linéaire.
La relation non linéaire doit être définie sur sur \(\left]-\infty ,\infty \right[\) . La phase non-linéaire dans les post-traitements correspond à la plage d’instants quand la relation non linéaire était non-nulle.
L’équation d’équilibre, pour une structure soumise à une accélération de sol horizontale \({a}_{x}\) dans la direction \(x\) , et ayant des termes de correction provenant de non-linéarités, s’écrit:
où \({F}_{c}\) est la force corrective due à la non linéarité du sol. Elle peut être, par exemple, définie par la relation suivante (cf. cas test SDND103):
avec:
Dans l’exemple ci dessus, on impose donc, sous l’opérande RELATION la fonction:
Non-linéarité : RELA_EFFO_VITE#
◊ RELATION = 'RELA_EFFO_VITE'
Cette relation permet de définir une relation force-vitesse sur un degré de liberté d’un nœud donné sous la forme d’une fonction non linéaire.
Les opérandes GROUP_NO, SOUS_STRUC, NOM_CMP et FONCTION ont le même sens pour les relations RELA_EFFO_DEPL et RELA_EFFO_VITE. Ils ne sont donc pas détaillés dans ce paragraphe.
Mot clé ARCHIVAGE#
◊ ARCHIVAGE
Mot clé facteur définissant l’archivage.
Opérande LIST_INST/INST#
◊ / LIST_INST = l_arch
Liste de réels définissant les instants de calcul pour lesquels la solution doit être archivée dans le concept résultat tran_gene.
◊ / INST
Instants de calcul pour lesquels la solution doit être archivée dans le concept résultattran_gene .
Opérande PAS_ARCH#
◊ PAS_ARCH= ipa
Entier définissant la périodicité d’archivage de la solution du calcul transitoire dans le concept résultat tran_gene.
Si ipa = 5 on archive tous les 5 pas de calcul.
Quelle que soit l’option d’archivage choisie, on archive le premier et le dernier pas de temps et tous les champs associés pour permettre une éventuelle reprise.
Remarque:
PAS_ARCHet LIST_INST/INSTpeuvent être tous les deux présents. Dans ce cas on archive l’union des instants définis par ces deux critères.
Opérande CRITERE#
◊ CRITERE =
Indique avec quelle précision la recherche de l’instant à archiver doit se faire:
“RELATIF” : intervalle de recherche [(1-prec).instant, (1+prec).instant]
“ABSOLU” : intervalle de recherche [instant-prec, instant+prec]
La valeur par défaut du critère de recherche est “RELATIF”.
Opérande PRECISION#
◊ PRECISION = / 1.E-06 [DEFAUT]
/ prec [R]
Indique avec quelle précision la recherche de l’instant à archiver doit se faire.
Opérande INFO#
◊ INFO = imp
Entier permettant de préciser le niveau d’impression dans le fichier MESSAGE.
Si INFO=1, on imprime un récapitulatif du calcul dynamique avec les options choisies, les matrices et le nombre de non-linéarités considérées. L’avancement du calcul est décompté par tranches de 5% de la durée totale de simulation.
Si INFO : 2, on imprime, en plus des informations écrites dans le cas où INFO vaut 1, l’avancement avec des tranches plus courtes de 1%. En présence de non-linéarités localisées, on imprime pour chaque obstacleles informations supplémentaires suivantes :
Le numéro et type de l’obstacle;
Le nom et les coordonnées dans le repère global du nœud de choc (des nœuds de choc dans le cas d’un choc entre structures mobiles);
L’orientation, dans le repère global, de la normale à l’obstacle;
La valeur de l’angle de vrille;
La valeur du jeu initial;
Si le mode VERI_CHOC est activé, on imprime également pour chaque nœud de choc et pour chaque mode, les valeurs des raideurs locales de choc et du taux de flexibilité locale et de la souplesse locale.
Opérande IMPRESSION#
◊ IMPRESSION
Mot clé facteur qui permet d’imprimer dans le fichier RESULTAT des grandeurs, non imprimables par un opérateur d’impression, telles que le déplacement local, la vitesse locale, les forces de contact aux nœuds de choc et la valeur cumulée sur tous les modes de la base modale de projection du taux de reconstitution de la solution statique.
Opérandes TOUT / NIVEAU#
Le mot clé NIVEAU permet d’imprimer un ou plusieurs tableau(x) parmi “DEPL_LOC”, “VITE_LOC”,”FORC_LOC” et ’TAUX_CHOC’. Avec TOUT = “OUI” (valeur par défaut), on imprime les quatre tableaux.
Opérandes INST_INIT / INST_FIN#
Ces deux mots clés permettent à l’utilisateur de filtrer les impressions dans chaque boucle sur les pas de temps.
Opérande UNITE_DIS_VISC#
◊ UNITE_DIS_VISC= unit
Les résultats concernant l’effort, les déplacements visqueux et relatifs entre les deux nœuds, ainsi que la dissipation du dispositif non-linéaire peuvent être sauvegardésdans un fichier directement exploitable par les commandes de code_aster .
Phase de contrôle#
Vérification sur les matrices#
Dans le cas d’un calcul par recombinaison modale, on vérifie que les matrices généralisées sont bien issues d’une projection sur une base commune et avec le même nombre de vecteurs de base. Dans le cas d’un calcul par sous-structuration dynamique, on vérifie que les matrices généralisées sont bien issues de la même numérotation généralisée.
Vérification et conseil sur le choix du pas de temps pour les schémas DIFF_CENTRE, DEVOGE et NEWMARK :#
On s’assure que le pas de temps choisi vérifie les conditions de stabilité du schéma numérique (critère de CFL):
dans le cas de NEWMARK, la stabilité est toujours assurée mais le dépassement du critère peut induire un manque de précision sur le résultat et est signalé par un message ; le calcul se poursuit (au risque de produire un résultat peu précis ou faux).
dans le cas des schémas de DIFF_CENTRE et DEVOGE, si l’opérande VERI_PAS vaut “OUI” (valeur par défaut), l’exécution est arrêtée, un pas de temps minimum est proposé. Si l’opérande VERI_PAS vaut “NON” ou s’il s’agit d’un schéma adaptatif, un message d’alarme est émis et le calcul se poursuit (au risque de produire un résultat peu précis ou faux).
Dans une analyse transitoire sans non-linéarité, il faut veiller à ce que le pas de temps soit tel que:
\(\mathit{dt}<0,1/{f}_{n}\) pour NEWMARK et DEVOGE
\(\mathit{dt}<0,05/{f}_{n}\) pour DIFF_CENTRE
\({f}_{n}\) étant la fréquence la plus élevée des modes de la base modale considérée.
Remarque:
On mentionne qu’avec des non linéarités localisées le pas de temps choisi doit être parfois très inférieur à cette valeur conseillée.
Phase d’exécution pour les schémas adaptatifs :#
L’exécution est interrompue lorsque le pas de temps atteint un pas minimal égal à PAS_MINI.
Remarques:
Le s schéma s ADAPT_ORDRE1/2 ( différences centrées ) ne restitue pas de façon exacte les pulsations propres d’un système, ce qui conduit à d’importantes erreurs de calcul dans les deux cas suivants:
Calcul d’un très grand nombre de périodes d’oscillations libres;
Calcul des oscillations d’un système très faiblement amorti ( \(\xi <{10}^{-3}\) ) excité sur une fréquence de résonance.
Dans ces deux cas, il est souvent nécessaire d’augmenter le paramètre NB_POIN_PERIODE.
Les méthodes “ADAPT_ORDRE1’et “ADAPT_ORDRE2’peuvent être utilisées en sous-structuration.
Le pas de temps peut être récupéré par l’opérateur RECU_FONCTION, avec la syntaxe suivante:
pas = RECU_FONCTION (
RESU_GENE = dynamoda
NOM_CHAM = “PTEM”
.…)
Prise en compte des effets d’interaction fluide-structure#
On décrit ci dessous les mots clés spécifiques au calcul de la réponse de systèmes mécaniques linéaires très faiblement amortis avec couplages fluidélastiques associés éventuellement à des non‑linéarités localisées aux nœuds de type chocs et frottements.
◊ BASE_ELAS_FLUI = meles
Base modale utilisée pour le calcul.
Concept de type melasflu produit par l’opérateur CALC_FLUI_STRU [U4.66.02] qui contient l’ensemble des bases modales calculées pour les différentes vitesses d’écoulement définies. Ce mot clé est obligatoire pour la méthode “ITMI”.
Le calcul transitoire sur base modale modifiée par le couplage fluidélastique s’effectue en prenant en compte les valeurs des amortissements ajoutés, dus à l’écoulement du fluide, qui sont présents dans le concept melasflu d’entrée. Les amortissements modaux, récupérés de la base fluidélastique, remplacent ceux renseignés sous le mot-clé global AMOR_REDUITde l’opérateur DYNA_VIBRA.
◊ NUME_VITE_FLUI = Nvitf
Vitesse d’écoulement retenue pour le calcul (numéro d’ordre).
Permet d’extraire dans le concept melasflu la base modale correspondant à la vitesse d’écoulement retenue (cf. [U4.66.02]).
Calcul de réponse transitoire sur base physique#
L’opérateur réalise l’intégration temporelle directe d’un problème mécanique linéaire transitoire de la forme:
où les matrices \(\mathrm{M},\mathrm{C},\mathrm{K}\) sont les matrices réelles assemblées du problème éléments finis (respectivement) de masse, d’amortissement et de rigidité du système.
Les \({\alpha}_{i}\) sont des fonctions du temps (cf. DEFI_FONCTION [U4.31.02]) et les \({\mathrm{F}}_{i}\) sont des vecteurs assemblés issus de chargements en force imposée (cf. AFFE_CHAR_MECA [U4.44.01]) ; ils peuvent être fournis directement sous forme de vecteurs assemblés ou sous forme de charges qui seront assemblées dans l’algorithme.
La solution \((\mathrm{X},\dot{\mathrm{X}},\ddot{\mathrm{X}})\) est calculée sur une discrétisation temporelle \({t}_{i}\) de l’intervalle d’étude précisé par l’utilisateur.
Opérande MODELE#
◊ MODELE= mo
Nom du modèle dont les éléments font l’objet du calcul dynamique.
Cet opérande est obligatoire lorsque l’on applique une excitation de type charge avec le mot-clé EXCIT (cf.[§4.7]).
Opérande CHAM_MATER#
◊ CHAM_MATER= chmat
Nom du champ de matériau affecté sur le modèle mo, nécessaire lorsque l’on applique une excitation de type charge avec le mot-clé EXCIT.
Opérande CARA_ELEM#
◊ CARA_ELEM= carac
Nom des caractéristiques des éléments de poutre, coque etc, nécessaire lorsque l’on applique une excitation de type charge avec le mot-clé EXCIT.
Matrices du système#
♦ MATR_MASS= m
Concept matrice assemblée de type matr_asse_DEPL_R correspondant à la matrice de masse du système.
♦ MATR_RIGI= k
Concept matrice assemblée de type matr_asse_DEPL_R correspondant à la matrice de rigidité du système.
◊ MATR_AMOR= c
Concept matrice assemblée de type matr_asse_DEPL_R correspondant à la matrice d’amortissement du système.
Remarques:
Les trois matrices doivent s’appuyer sur la même numérotation et être construites avec le même mode de stockage. C’est vrai aussi d’une matrice d’amortissement construite comme combinaison linéaire des matrices de rigidité et de masse par la méthode de Rayleigh: utiliser la matrice de la matrice de masse complète pour construire la matrice d’amortissement et la matrice de masse diagonale (schémas explicites tels que DIFF_CENTRE ou ADAPT) pour l’intégration en temps peut mener à une instabilité numérique.
Schémas d’intégration. Mot clé SCHEMA_TEMPS#
Sous ce mot-clé on peut renseigner un schéma d'intégration avec, éventuellement, ses paramètres. Les schémas disponibles sont à déclarer sous l'opérande SCHEMA.
Opérande SCHEMA#
|'NEWMARK'
Schéma d’intégration implicite de type NEWMARK. C’est le schéma par défaut pour l’analyse transitoire sur base physique.
On peut préciser les paramètres d’intégration \(\beta\) et \(\gamma\) :
◊ BETA= beta
Valeur du paramètre \(\beta\) pour la méthode de NEWMARK. Par défaut \(\beta =0.25\) .
◊ GAMMA= gamm
Valeur du paramètre \(\gamma\) pour la méthode de NEWMARK. Par défaut \(\gamma =0.5\) .
Voir [R5.05.02] pour le choix d’autres valeurs.
|'WILSON'
Schéma d’intégration implicite de type WILSON. Avec ce schéma on peut renseigner:
◊ THETA= th
Valeur du paramètre \(\theta\) pour la méthode de WILSON. Par défaut \(\theta =1,4\) .
Ce schéma ne doit pas être utilisé lorsque l’on impose des déplacements non nuls par l’intermédiaire d’un vecteur assemblé. Voir [R5.05.02].
| 'DIFF_CENTRE'
Schéma d’intégration explicite par différences centrées. L’utilisation de ce schéma impose certaines restrictions d’utilisation énumérées au [§6.14]. La description théorique du schéma est faite dans [R5.05.02].
| 'ADAPT_ORDRE2'
Schéma d’intégration explicite à pas de temps adaptatif, variante du schéma des différences centrées. L’utilisation de ce schéma impose certaines restrictions d’utilisation énumérées au [§6.14] (voir [R5.05.02]).
Remarque:
On ne peut pas utiliser les schémas **explicites(* DIFF_CENTRE , ADAPT_ORDRE2 ) avec les **éléments de plaque et coque.*
Mot-clé ETAT_INIT#
Cette fonctionnalité permet une poursuite d’un calcul transitoire, en prenant comme état initial un résultat obtenu par un calcul précédent avec DYNA_LINE_TRAN. Elle permet aussi de définir des conditions initiales de type champs aux nœuds.
Remarque:
Pour les schémas d’ordre supérieur ( NEWMARK ou WILSON ), l’accélération initiale ( acce_init ) joue un rôle important dans l’initialisation du schéma.
Opérandes RESULTAT#
♦ / RESULTAT = dy
Concept de type dyna_trans issu d’un calcul précédent avec DYNA_LINE_TRAN, et définissant les conditions initiales pour le nouveau calcul.
Opérandes DEPL/ VITE/ACCE#
/ DEPL = do
Concept correspondant aux déplacements initiaux (champ aux nœuds de grandeur DEPL_R).
VITE = vo
Concept correspondant aux vitesses initiales (champ aux nœuds de grandeur DEPL_R).
ACCE = ao
Concept correspondant aux accélérations initiales (champ aux nœuds de grandeur DEPL_R).
Si le mot clef est présent, on utilise le champ d’accélération entré pour initialiser les différents schémas d’intégration en temps selon les algorithmes décrits dans le document [R5.05.02].
S’il est absent on calcule une accélération initiale par la formule suivante:
\(\mathit{M.ao}=\mathit{Fext}(t=\text{to})–\mathit{C.vo}–\mathit{K.xo}\)
R emarque importante :
Lorsque l’état initial du système dynamique est défini par des champs de DEPL, VITE, et/ou ACCE, les composants de ces champs qui n’ont pas été explicitement renseignés lors de la création des champs sont considérés nuls lors du calcul dynamique transitoire.
Opérandes NUME_ORDRE/ INST_INIT#
◊ / NUME_ORDRE = nuord
nuord désigne le numéro d’archivage du calcul précédent à extraire et à prendre comme état initial dans le cas d’une reprise.
/ INST_INIT = to
Instant du calcul précédent à extraire et à prendre comme état initial dans le cas d’une reprise.
En l’absence de NUME_ORDRE et INST_INIT, l’instant de reprise est pris égal au dernier instant de calcul précédent archivé.
Opérande CRITERE#
◊ CRITERE =
Indique avec quelle précision la recherche de l’instant doit se faire:
“RELATIF” : intervalle de recherche [(1-prec).instant, (1+prec).instant]
“ABSOLU” : intervalle de recherche [instant-prec, instant+prec]
La valeur par défaut du critère de recherche est “RELATIF”.
Opérande PRECISION#
◊ PRECISION = / 1.E-06 [DEFAUT]
/ prec [R]
Indique avec quelle précision la recherche de l’instant doit se faire.
Mot-clé EXCIT#
◊ EXCIT=
Opérande permettant de définir plusieurs excitations spatio-temporelles. Soit en indiquant un vecteur assemblé correspondant à un chargement, soit des charges qui conduiront au calcul et à l’assemblage d’un second membre. Le vecteur assemblé peut être associé à une fonction d’évolution temporelle ou un coefficient multiplicateur constant.
Le chargement total est la somme des chargements définis par toutes les occurrences du mot-clé EXCIT (cf. [§4.7.2]).
Opérandes VECT_ASSE / CHARGE#
♦ / VECT_ASSE= vecti
Vecteur assemblé correspondant à un chargement (concept de type cham_no_DEPL_R).
◊ / COEF_MULT= ci
Coefficient multiplicatif du vecteur assemblé vecti.
/ FONC_MULT =:math:{alpha}_{i}
Voir [§4.7.2].
/ CHARGE= chi
chi est le chargement comportant éventuellement l’évolution d’un champ de température précisé par la \(i\) ème occurrence de EXCIT.
Voir [§4.7.2].
Opérande FONC_MULT#
◊ FONC_MULT=:math:`{\alpha}_{i}`
\({\alpha}_{i}\) est la fonction du temps multiplicative du vecteur assemblé ou du chargement précisé à la \(i\) èmeoccurrence de EXCIT.
Le chargement \(\text{ch}\) et les conditions aux limites pour \(n\) occurrences du mot-clé facteur EXCIT sont:
Le ou les champs de température ne sont pas multipliés par \({\alpha}_{i}\) en analyse thermomécanique.
Remarque importante :
Les conditions aux limites de type déplacement imposé non nul peuvent être imposées avec un vecteur assemblé ou une charge **; il faut alors utiliser impérativement le schéma de Newmark.*
Opérandes MULTI_APPUI / ACCE / VITE / DEPL / DIRECTION / GROUP_NO / MODE_STAT#
Dans le cas d’une excitation multi-appuis (MULT_APPUI= “OUI”), les autres opérandes ont exactement la même signification que dans le mot-clé facteur EXCIT de l’opérateur DYNA_TRAN_MODAL [U4.53.21].
Mot clé EXCIT_RESU#
Mot clé permettant de définir plusieurs compléments de chargement sous forme d’une évolution transitoire de vecteurs assemblés seconds membres.
Mot-clé AMOR_MODAL#
Ce mot-clé permet de prendre en compte un amortissement équivalent à de l’amortissement modal décomposé sur une base de modes pré-calculée sous forme de concept de type mode_meca. Cet amortissement est globalement pris en compte dans l’équation d’équilibre dynamique comme une force correctrice au second membre \(-C\dot{X}\) .
Remarque:
Cette façon d’introduire l’amortissement modal dans un problème calculé sur base physique peut réduire les propriétés de stabilité des schémas en temps. En particulier pour le schéma d’intégration “NEWMARK” elle peut conduire à réduire le pas de temps par rapport au pas de temps sans amortissement pour éviter des divergences numériques.
Opérandes MODE_MECA / AMOR_REDUIT / NB_MODE#
♦ MODE_MECA = mode
♦ AMOR_REDUIT = l_amor
◊ NB_MODE = nbmode
Le concept mode de type mode_meca (entré par l’opérande MODE_MECA) représente la base de modes pré-calculée sur laquelle on décompose l’amortissement modal. Cette base doit impérativement avoir le même profil de numérotation que celui du système dynamique défini par les paramètres du mot-clé SOLVEUR [§4.11]. Il est possible de tronquer la base modale à un nombre de modes défini par NB_MODE. A défaut, on prend tous les modes de la base modale.
Les amortissements modaux sous forme réduite sont donnés sous forme d’une liste de réels dont le nombre de termes est inférieur ou égal au nombre de modes pris en compte. Si le nombre de termes de la liste est strictement inférieur, on étend cette liste avec la valeur de son dernier terme jusqu’à ce que sa taille atteigne le nombre de modes calculés.
Mot-clé ENERGIE#
◊ ENERGIE = _F( … )
Ce mot-clé permet d’activer le calcul du bilan d’énergie, son affichage en cours de calcul et son stockage dans la table de nom PARA_CALC. Le bilan d’énergie peut être extrait de cette table à l’aide de la commande RECU_TABLE [U4.71.02].
Mot-clé INCREMENT#
Mot-clé facteur définissant les instants de calcul.
Opérandes LIST_INST / PAS#
Pour les schémas de Newmark et Wilson:
♦ / LIST_INST = l_temp
Concept liste de réels de type listr8.
Liste de réels définissant les instants \({t}_{i}\) de calcul de la solution
Pour les schémas des différences centrées et à pas de temps adaptatif:
/ PAS = dt
Désigne le pas de temps utilisé par l’algorithme. Ce mot-clé est obligatoire pour le schéma des différences centrées et pour le schéma adaptatif et non disponible pour les schémas de Newmark et Wilson.
Pour le schéma adaptatif, il désigne à la fois le pas de temps initial et le pas de temps maximal utilisés par l’algorithme.
Ce paramètre doit être suffisamment faible:
pour permettre le calcul des phases statiques (qui utilisent toujours le pas maximal),
pour démarrer correctement l’algorithme.
Il doit cependant être suffisamment élevé pour ne pas pénaliser l’ensemble du calcul.
Opérandes INST_INIT / INST_FIN / NUME_FIN#
Pour les schémas des différences centrées et à pas de temps adaptatif :
◊ INST_INIT = ti
En cas de reprise on utilise le mot-clé ETAT_INIT [§4.6] : sous ce mot-clé, l’instant initial est récupéré avec l’opérande INST_INIT ou pris égal au dernier instant de calcul précédent archivé.
L’opérande INST_INIT sous INCREMENT doit donc être utilisée uniquement s’il n’y a pas reprise d’un calcul précédent.
◊ / INST_FIN = tf
Instant de fin du calcul transitoire. Obligatoire pour les schémas des différences centrées et à pas de temps adaptatif.
/ NUME_FIN = nufin
Numéro de l’instant de fin de calcul dans LIST_INST (uniquement pour les schémas de Newmark et Wilson).
Si INST_INIT n’est pas présent , l’instant initial est zéro.
Opérandes VITE_MIN / COEF_MULT_PAS / COEF_DIV_PAS / PAS_LIMI_RELA / NB_POIN_PERIODE / NMAX_ITER_PAS / PAS_MINI#
Ces opérandes ne concernent que le schéma à pas de temps adaptatif.
◊ VITE_MIN = / 'NORM' [DEFAUT]
/ “MAXI”
Méthode de calcul de la vitesse de référence utilisée pour évaluer la fréquence apparente.
Quand le dénominateur de la fréquence apparente \(({x}_{n}-{x}_{n-1})\) devient faible, la fréquence apparente peut devenir très élevée, ce qui conduit à un raffinement injustifié du pas de temps. Pour y remédier, l’algorithme utilise le critère suivant pour chaque degré de liberté \(i\) :
\({v}_{min}^{i}\) peut être calculée de deux façons différentes selon la valeur de VITE_MIN:
“NORM” : \({v}_{\min}^{i}({t}_{n})=\mathrm{Max}(\frac{\mathrm{Max}({\dot{x}}_{n+1/2}^{k},{\dot{x}}_{n+1/2}^{l})}{100},{10}^{-15}{\mathrm{ms}}^{-1})\) où \(k\) et \(l\) sont les degrés de liberté de même nature que le degré de liberté \(i\) les plus proches de \(i\) dans la numérotation (\(\mathit{DX}\) ou \(\mathit{DY}\) ou \(\mathit{DZ}\) …).
“MAXI” : \({v}_{\min}^{i}({t}_{n})=\underset{0<{t}_{p}<{t}_{n}}{\mathrm{Max}}(\frac{\mid {v}^{i}({t}_{p})\mid }{100},{10}^{-15}{\mathrm{ms}}^{-1})\) pour le degré de liberté \(i\) .
Peut être utilisé si l’ordre de grandeur de la vitesse ne varie pas trop au cours du temps.
◊ COEF_MULT_PAS = cmp
Coefficient de déraffinement du pas de temps (\(>1\) ) lorsque l’erreur est suffisamment faible :
\(\Delta {t}_{n}<\frac{0.75}{{\mathit{Nf}}_{{\mathit{AP}}_{n}}}\) depuis plus de 5 pas consécutifs \(\mathrm{\Rightarrow }\Delta {t}_{n+1}=min(\mathit{cmp}\Delta {t}_{n},\Delta {t}_{max})\)
avec \(\Delta {t}_{max}=\Delta {t}_{\mathit{initial}}\)
Sa valeur par défaut (\(\mathit{cmp}=1.1\) ) garantit stabilité et précision, mais il peut en général être augmenté (au plus jusqu’à \(1.3\) ) pour accélérer l’intégration.
◊ COEF_DIVI_PAS = cdp
Coefficient de raffinement du pas de temps (\(>1\) ) lorsque l’erreur est supérieure à 1, que le nombre d’itérations maximales (NMAX_ITER_PAS) n’est pas atteint et que le pas de temps minimal n’est pas atteint :
\(\Delta {t}_{n}>\frac{1}{{\mathit{Nf}}_{{\mathit{AP}}_{n}}},\mathit{Niter}<{\mathit{Niter}}_{max}\) et \(\Delta {t}_{n}>\mathit{plr}\mathrm{\ast }\Delta {t}_{\mathit{initial}}\mathrm{\Rightarrow }\Delta {t}_{n}=\frac{\Delta {t}_{n}}{\mathit{cdp}}\)
Sa valeur par défaut est de \(1.3334\) , soit une réduction d’un facteur \(0,75\) .
◊ PAS_LIMI_RELA = plr
Coefficient appliqué au pas de temps initial pour définir la limite de raffinement et donc le pas de temps minimal :
\(\Delta {t}_{min}=\mathit{plr}\mathrm{\ast }\Delta {t}_{\mathit{initial}}\)
◊ NB_POIN_PERIODE = N
Nombre de points par période apparente. C’est ce paramètre qui fixe la précision du calcul. Il doit être au moins égal à 20 ; sa valeur par défaut (50) garantit une précision satisfaisante (de l’ordre de 1à 2%) dans la plupart des cas.
◊ NMAX_ITER_PAS
Nombre maximal de réductions du pas de temps par pas de calcul :
si \(\mathit{err}>1\) et \({N}_{\mathit{iter}}<{N}_{\mathit{iter}}max\) : \(\Delta {t}_{n}=\mathit{cdp}\mathrm{\ast }\Delta {t}_{n}\)
Il est par défaut égal à 16, ce qui limite le coefficient de réduction du pas à \({(1/1,33)}^{16}={10}^{-2}\) par itération. NMAX_ITER_PAS peut être :
augmenté pour permettre au pas de temps de chuter de façon plus brutale,
diminué si le pas de temps semble excessivement raffiné.
◊ PAS_MINI = dtmin
Valeur minimale du pas de temps. Si les conditions de diminution du pas de temps sont remplies, le pas de temps courant pourra alors diminuer jusqu’à cette valeur limite.
Si l’utilisateur ne donne pas de valeur à ce paramètre facultatif, alors le code calculera le pas de temps minimal à partir de PAS_LIMI_RELA.
Mot-clé ARCHIVAGE#
◊ ARCHIVAGE =
Mot-clé facteur définissant l’archivage. En l’absence de ce mot-clé facteur, tous les pas de temps sont archivés.
Quelle que soit l’option d’archivage choisie, on archive le dernier pas de temps et tous les champs associés pour permettre une éventuelle poursuite.
Opérandes LIST_INST/INST#
◊ / LIST_INST = list
Liste de réels définissant les instants de calcul pour lesquels la solution doit être archivée dans le concept résultat dyna_tran.
◊ / INST
Instants de calcul pour lesquels la solution doit être archivée dans le concept résultatdyna_tran.
Opérande PAS_ARCH#
/ PAS_ARCH = ipa
Entier définissant la périodicité d’archivage de la solution du calcul transitoire dans le concept résultat dyna_trans.
Si ipa = 5 on archive tous les 5 pas de calcul.
Remarque:
PAS_ARCHet LIST_INST/INSTsont tous les deux pris en compte dans le mot-clé ARCHIVAGE, il faut veiller à fixer PAS_ARCHà une valeur supérieur au nombre de pas de calculs si l’on veut piloter uniquement par LIST_INST/INST.
Opérande CRITERE#
◊ CRITERE =
Indique avec quelle précision la recherche de l’instant à archiver doit se faire:
“RELATIF” : intervalle de recherche [(1-prec).instant, (1+prec).instant]
“ABSOLU” : intervalle de recherche [instant-prec, instant+prec]
La valeur par défaut du critère de recherche est “RELATIF”.
Opérande PRECISION#
◊ PRECISION = /1.E-06 [DEFAUT]
- /prec
[R]
Indique avec quelle précision la recherche de l’instant à archiver doit se faire.
Opérande CHAM_EXCLU#
◊ CHAM_EXCLU = ( I 'DEPL',
I “VITE”, I “ACCE”, )
Permet d’exclure l’archivage d’un ou plusieurs champs parmi “DEPL”, “VITE” et “ACCE”.
Cette exclusion est ignorée pour le dernier instant de calcul : les trois champs sont nécessaires pour une POURSUITE.
Mot-clé OBSERVATION#
◊ OBSERVATION= _F()
◊ TITRE = titre
Ce mot clé permet de post-traiter certains champs aux nœuds (DEPL, VITE, ACCE) sur des parties de modèle à des instants d’une liste (dite d’observation) généralement moins raffinée que la liste des instants archivés définie dans le mot clé ARCHIVAGE (où on stocke tous les champs sur tout le modèle). Il sert essentiellement à des économies de stockage, mais aussi à évaluer des champs sur des parties réduites du maillage, sans avoir besoin de post-traiter après le calcul.
Ce mot clé est répétable et permet la création d’une table d’observation que l’on pourra extraire à l’aide de la commande RECU_TABLE. Cf. [U4.51.03] (3.22.8) pour le contenu de table détaillé.
On ne peut utiliser que 99 occurrences du mot-clef OBSERVATIONau maximum.
Il est possible de nommer une occurrence de l’observation (colonne NOM_OBSERVATION) en utilisant le mot-clef TITRE. S’il n’est pas utilisé, la colonne NOM_OBSERVATIONcontient OBSERVATION_xxavec xxvariant de 1 à 99.
Opérandes LIST_INST/INST/PAS_OBSE/OBSE_ETAT_INIT#
◊ /LIST_INST = list_r8
- /INST
= l_r8
- /PAS_OBSE
= npas
- /OBSE_ETAT_INIT
= /”OUI”, [DEFAUT]
/”NON”
Cf. [U4.51.03]pour la syntaxe détaillée.
Opérandes PRECISION/CRITERE#
◊ PRECISION = prec
◊ CRITERE = /'ABSOLU'
/”RELATIF”
Cf. [U4.71.00]pour la syntaxe détaillée.
Opérandes NOM_CHAM/NOM_CMP#
♦ NOM_CHAM = ( I 'DEPL',
I “VITE”, I “ACCE”, )
◊ NOM_CMP = nomcmp
Cf. [U4.51.03]pour la syntaxe détaillée.
Opérandes TOUT/NOEUD/GROUP_NOEUD/MAILLE/GROUP_MA#
◊ /TOUT = 'NON' [DEFAUT]
“OUI” /NOEUD = no [no] /GROUP_NO = grno [grno] /MAILLE = lma [ma] /GROUP_MA = lgrma [grma]
Cf. [U4.51.03] pour la syntaxe détaillée.
Opérandes EVAL_CMP/FORMULE/EVAL_CHAM#
◊ EVAL_CMP = /'VALE', [DEFAUT]
/”FORMULE”
◊ FORMULE = form [ formule_aster ]
◊ EVAL_CHAM= /”VALE”, [DEFAUT]
/”MIN”, /”MAX”, /”MOY”,
Cf. [U4.51.03]pour la syntaxe détaillée.
Phase de contrôle#
L’utilisation des schémas des différences centrées et adaptatifs impose certaines restrictions d’utilisation:
ces deux schémas nécessitent l’utilisation d’une matrice de masse diagonale. Un test vérifie que la matrice de masse a été créée avec l’option “MASS_MECA_DIAG” de CALC_MATR_ELEM. D’autre part, la matrice de masse doit être stockée en ligne de ciel,
il ne doit pas y avoir d’autres conditions aux limites que des degrés de liberté bloqués.
Un test vérifie qu’il n’y a pas de conditions aux limites de type liaisons entre degrés de liberté.
Il n’est pas non plus possible d’imposer des déplacements non nuls par l’intermédiaire d’un vecteur assemblé,
pour le schéma des différences centrées, on s’assure que le pas de temps choisi vérifie les conditions de stabilité:
\(\mathit{dt}<0,05/{f}_{max}\) avec \({f}_{max}=\underset{1\le i\le \mathit{nddl}}{max}(\frac{1}{2\pi }\sqrt{\frac{{k}_{ii}}{{m}_{ii}}})\) et \({k}_{ii}\) et \({m}_{ii}\) termes diagonaux des matrices de raideur et de masse.
Calcul de réponse harmonique#
On résout l’équation suivante en domaine fréquentiel:
Où :
\(\mathrm{K}\) représente une matrice de rigidité réelle ou complexe (cas de l’amortissement hystérétique)
\(\mathrm{M}\) représente une matrice de masse
\(\mathrm{C}\) représente une matrice d’amortissement visqueux
\(\mathrm{Q}\) représente une matrice d’impédance acoustique issue d’une formulation en déplacement-pression-potentiel \((\mathrm{u},p,\varphi )\) , cf. [R4.02.02].
\(P\) est un point courant de la structure.
\(\omega =2\pi f\) : pulsation d’excitation
\({\mathrm{g}}_{i}(P)\) : description spatiale de l’excitation
\({h}_{i}(f)\) : description fréquentiellede l’excitation
\(\mathrm{x}\) : réponse complexe
L’amortissement de la structure peut être visqueux ou hystérétique [U2.06.03] [R5.05.04]. Dans le cas d’un amortissement hystérétique, on dispose d’une matrice de rigidité complexe et on résout l’équation suivante:
avec \(\mathrm{K}\) : matrice de rigidité complexe.
Cet opérateur est utilisable en force imposée ou en déplacement imposé (résolution en référentiel absolu) ou en force d’inertie d’entraînement imposée (résolution en référentiel relatif).
Opérande RESULTAT#
◊ RESULTAT = harm
Nom de la structure de données résultat à enrichir. Ce mot-clé est obligatoire si on est en mode concept ré-entrant (reuse).
Opérande MODELE#
◊ MODELE = mo
Nom du concept définissant le modèle dont les éléments font l’objet du calcul harmonique.
Opérande CHAM_MATER#
◊ CHAM_MATER = chmat
Nom du concept définissant le champ de matériau affecté sur le modèle mo.
Opérande CARA_ELEM#
◊ CARA_ELEM = carac
Nom du concept définissant les caractéristiques des éléments de poutre, plaques, coques, etc…
Opérande MATR_MASS#
♦ MATR_MASS = m
Nom du concept matrice assemblée \(\mathrm{M}\) correspondant à la matrice de masse du système.
Opérande MATR_RIGI#
♦ MATR_RIGI = k
Nom du concept matrice assemblée \(\mathrm{K}\) correspondant à la matrice de rigidité du système. Un amortissement hystérique est obtenu avec une matrice de rigidité complexe.
Opérande MATR_AMOR#
◊ MATR_AMOR = c
Nom du concept matrice assemblée \(\mathrm{C}\) correspondant à la matrice d’amortissement visqueux du système.
Mot-clé AMOR_MODAL#
Mot-clé facteur pour renseigner l’amortissement visqueux sous la forme de listes d’amortissement modal réduit (pourcentage de l’amortissement critique) avec les opérandes suivants, possible seulement dans le cas d’une analyse harmonique sur base modale.
Opérandes AMOR_REDUIT / LIST_AMOR#
/ AMOR_REDUIT = la
Liste de tous les amortissements visqueux modaux réduits: \(({\eta}_{1},{\eta}_{2},\mathrm{...},{\eta}_{n})\) .
**Remarque:si le nombre d’amortissements réduits donnés est inférieur au nombre de vecteurs de base utilisés dans la base modale, les amortissements des vecteurs supplémentaires sont pris égaux au dernier amortissement de la liste.*
/ LIST_AMOR = l_amor
Nom du concept de type listr8 contenant la liste des amortissements modaux visqueux réduits.
Opérande MATR_IMPE_PHI#
◊ MATR_IMPE_PHI = imp
Nom du concept matrice assemblée \(\mathrm{Q}\) correspondant à la matrice d’impédance pour un système fluide-structure dont la formulation est en déplacement-pression-potentiel \((\mathrm{u},p,\varphi )\) [R4.02.02].
Opérandes FREQ/LIST_FREQ#
♦ / FREQ = lf
Liste de toutes les fréquences \(f\) de calcul: (f1, f2, …, fn).
/ LIST_FREQ = cf
Nom du concept de type listr8 contenant la liste des fréquences \(f\) de calcul.
Opérandes TOUT_CHAM / NOM_CHAM#
◊ / TOUT_CHAM = 'OUI'
/ NOM_CHAM = | “DEPL” | “VITE” | “ACCE”
Choix des champs à calculer pour représenter la réponse: déplacement, vitesse, accélération ou les trois.
Mot clé EXCIT#
♦ EXCIT
Mot clé facteur permettant de définir plusieurs types d’excitations. Soit en indiquant un vecteur assemblé correspondant à un chargement, soit des charges qui conduiront au calcul et à l’assemblage d’un second membre. Pour chaque occurrence du mot clé facteur, on définit une composante de l’excitation sous la forme \((h(f),\mathrm{g}(P),\phi )\) , que l’on peut aussi multiplier par des fonctions multiplicatrices. Ce mot clé doit être répété autant de fois qu’il y a de vecteurs chargement.
Opérandes VECT_ASSE/VECT_ASSE_GENE/CHARGE#
Permettent de définir \({\mathrm{g}}_{i}(P)\) discrétisation spatiale du chargement, sous forme d’un champ aux nœuds correspondant à une ou plusieurs charges de force ou de mouvement imposé.
♦ / VECT_ASSE = vecti
Nom du concept produit par:
l’opérateur ASSE_VECTEUR en force imposée ou en force d’inertie d’entraînement en accélération imposée dans un référentiel absolu. Les amplitudes de l’excitation peuvent être définies dans les concepts de type charge correspondante. Le champ attendu est un champ aux nœuds de grandeur DEPL_R, DEPL_C ou PRES_C.
/ VECT_ASSE_GENE = vect_gene
Nom du concept produit par:
l’opérateur PROJ_VECT_BASE qui permet de projeter un vecteur assemblé (force imposée ou force d’entraînement en accélération imposée dans un référentiel absolu) sur une base modale ou une base de Ritz.
l’opérateur ASSE_VECT_GENE qui permet de projeter un chargement sur une base définie sur un modèle généralisé pour les calculs de sous-structuration dynamique.
/ CHARGE = chi
chi nom du concept de chargement créé par appel à la commande AFFE_CHAR_MECA [U4.44.01].
Le mot-clé MODELE doit être renseigné si on utilise le mot-clé CHARGE.
Opérandes FONC_MULT_C / COEF_MULT_C / FONC_MULT / COEF_MULT#
Permettent de définir \({h}_{i}(f)\) fonction, complexe ou réelle, définissant la dépendance de l’excitation en fonction de la fréquence, appliquée à toutes les composantes du champ au nœud associé à cette occurrence. Plusieurs possibilités sont offertes:
♦ / FONC_MULT_C = hci
Nom du concept de type fonction_C ou formule_C définissant une fonction \({h}_{i}(f)\) complexe de la fréquence \(f\) ,
/ COEF_MULT_C = aci
Coefficient complexe multiplicateur du chargement, indépendant du chargement,
/ FONC_MULT = hi
Concept de type fonction, formule ou nappe définissant une fonction \({h}_{i}(f)\) réelle de la fréquence \(f\) ,
/ COEF_MULT = ai
Coefficient réel multiplicateur du chargement, indépendant du chargement.
Opérande PUIS_PULS#
◊ PUIS_PULS = ni
Permet de définir la puissance de la pulsation, cf. éq.(), lorsque le chargement est fonction de la fréquence; par défaut \({n}_{i}=0\) . Par exemple pour prendre en compte le dérivation temporelle d’un chargement; exemple: déplacement imposé vs vitesse imposée…
Opérande PHAS_DEG#
◊ PHAS_DEG = phi
Permet de définir la phase de chaque composante de l’excitation en degrés par rapport à une référence de phase unique pour toutes les excitations \({h}_{i}(f)\) ; par défaut \({\varphi}_{i}=0\) .
Remarque#
Pour un problème à mouvement imposé en déplacement, on définit les degrés de liberté bloqués (conditions cinématiques préalables à la construction du cham_no); on peut ensuite choisir une excitation:
en déplacement imposé \(n=0\) , \(\varphi =0\) degré,
en vitesse imposée \(n=1\) , \(\varphi =90\) degrés,
en accélération imposée \(n=2\) , \(\varphi =180\) degrés.
Opérande EXCIT_RESU#
◊ EXCIT_RESU
Ce mot-clé facteur permet de définir plusieurs chargements sous forme d’une évolution harmonique de type dyna_harmo de vecteurs assemblés seconds membres, calculée sur la base physique. Cette possibilité est disponible sur base physique et sur base modale réduite ou de Ritz.
Mot clé CHAR_GENE#
◊ CHAR_GENE
Ce mot-clé permet de définir un chargement de type char_gene (voir [U4.44.06]) qui impose des relations linéaires entre degrés de liberté généralisés.
Le problème à résoudre est de la forme suivante :
Où :
\(- \lambda\) représente les degrés de liberté de Lagrange additionels,
\(- B\) représente la matrice des coefficients à imposer entre les modes,
\(- \beta\) représente les valeurs des relations linéaires à appliquer.
Opérande RESULTAT#
Ce mot-clé permet de définir les seconds membres à extraire pour chaque fréquence de calcul à partir d’un résultat déjà calculé comportant des champs de forces nodales.
♦ RESULTAT = resuforc
Nom du concept d’évolution harmonique de seconds membres produits par l’enchaînement de l’opérateur CALC_FORC_NONL [U4.84.21] puis de l’opérateur REST_SPEC_TEMP [U4.63.34]. L’opérateur CALC_FORC_NONLpermet de produire une évolution transitoire de seconds membres. L’opérateur REST_SPEC_TEMP transforme cette évolution transitoire en évolution harmonique. Un exemple d’utilisation est fourni dans le cas test SDLS119A.
Opérande COEF_MULT_C#
♦ COEF_MULT_C = aci
Coefficient complexe multiplicateur du vecteur second membre extrait du résultat resuforc pour chaque fréquence de calcul.
Opérande INFO#
◊ INFO = inf
Permet d’effectuer dans le fichier message diverses impressions intermédiaires permettant de suivre l’avancement du calcul.
Par défaut, si INFO=1, on imprime l’avancement du calcul harmonique avec un pas qui correspond au maximum à 5% du nombre total de fréquences. La règle générale est d’imprimer systématiquement les première et dernière fréquences ainsi qu’un nombre maximal de 20 fréquences au milieu.
Si INFO=2, une impression est effectuée pour chaque fréquence et permet de suivre plus précisément l’avancement du calcul.