u4.44.11 Opérateur DEFI_CONTACT#
Syntaxe#
Détail de la syntaxe
char_contact = DEFI_CONTACT(
◆ MODELE = modele,
◇ INFO = / 1,
/ 2,
◇ FORMULATION = / "CONTINUE",
/ "DISCRETE" (par défaut),
/ "LIAISON_UNIL",
◇ FROTTEMENT = / "COULOMB",
/ "SANS" (par défaut),
# Si: ((equal_to("FORMULATION", 'CONTINUE')) or (equal_to("FORMULATION", 'DISCRETE')))
◇ STOP_INTERP = / "NON" (par défaut),
/ "OUI",
◇ LISSAGE = / "NON" (par défaut),
/ "OUI",
◇ VERI_NORM = / "NON",
/ "OUI" (par défaut),
# Si: equal_to("FORMULATION", 'DISCRETE')
◇ ALGO_RESO_GEOM = "POINT_FIXE",
◇ REAC_GEOM = / "AUTOMATIQUE" (par défaut),
/ "CONTROLE",
/ "SANS",
# Si: equal_to("REAC_GEOM", 'AUTOMATIQUE')
◇ ITER_GEOM_MAXI = int (défaut: 10),
◇ RESI_GEOM = float (défaut: 0.01),
# Si: equal_to("REAC_GEOM", 'CONTROLE')
◇ NB_ITER_GEOM = int (défaut: 2),
# Si: equal_to("FORMULATION", 'CONTINUE')
◇ ALGO_RESO_GEOM = / "NEWTON",
/ "POINT_FIXE" (par défaut),
◇ CONT_STAT_ELAS = int (défaut: 0),
# Si: equal_to("ALGO_RESO_GEOM", 'NEWTON')
◇ RESI_GEOM = float (défaut: 1e-06),
# Si: equal_to("ALGO_RESO_GEOM", 'POINT_FIXE')
◇ REAC_GEOM = / "AUTOMATIQUE" (par défaut),
/ "CONTROLE",
/ "SANS",
# Si: equal_to("REAC_GEOM", 'AUTOMATIQUE')
◇ ITER_GEOM_MAXI = int (défaut: 10),
◇ RESI_GEOM = float (défaut: 0.01),
# Si: equal_to("REAC_GEOM", 'CONTROLE')
◇ NB_ITER_GEOM = int (défaut: 2),
# Si: equal_to("FORMULATION", 'DISCRETE')
◇ ITER_CONT_MULT = int (défaut: 4),
# Si: equal_to("FORMULATION", 'CONTINUE')
◇ ALGO_RESO_CONT = / "NEWTON" (par défaut),
/ "POINT_FIXE",
◇ RESI_CONT = float (défaut: -1),
# Si: equal_to("ALGO_RESO_CONT", 'POINT_FIXE')
◇ ITER_CONT_TYPE = / "MAXI" (par défaut),
/ "MULT",
# Si: equal_to("ITER_CONT_TYPE", 'MULT')
◇ ITER_CONT_MULT = int (défaut: 4),
# Si: equal_to("ITER_CONT_TYPE", 'MAXI')
◇ ITER_CONT_MAXI = int (défaut: 30),
# Si: equal_to("FROTTEMENT", 'COULOMB') and equal_to("FORMULATION", 'CONTINUE')
◇ ALGO_RESO_FROT = / "NEWTON" (par défaut),
/ "POINT_FIXE",
# Si: equal_to("ALGO_RESO_FROT", 'POINT_FIXE')
◇ ITER_FROT_MAXI = int (défaut: 10),
◇ RESI_FROT = float (défaut: 0.0001),
# Si: equal_to("ALGO_RESO_FROT", 'NEWTON')
◇ RESI_FROT = float (défaut: 0.0001),
# Si: equal_to("FORMULATION", 'DISCRETE')
◇ STOP_SINGULIER = / "NON",
/ "OUI" (par défaut),
◇ NB_RESOL = int (défaut: 10),
◇ RESI_ABSO = float,
◇ ITER_GCP_MAXI = int (défaut: 0),
◇ RECH_LINEAIRE = / "ADMISSIBLE" (par défaut),
/ "NON_ADMISSIBLE",
◇ PRE_COND = / "DIRICHLET",
/ "SANS" (par défaut),
# Si: equal_to("PRE_COND", 'DIRICHLET')
◇ COEF_RESI = float (défaut: -1.0),
◇ ITER_PRE_MAXI = int (défaut: 0),
# Si: equal_to("FORMULATION", 'LIAISON_UNIL')
◆ ZONE = _F(
◆ / GROUP_MA = list[grma],
/ GROUP_NO = list[grno],
◆ NOM_CMP = list[text],
◆ COEF_IMPO = fonction / formule / nappe,
◆ COEF_MULT = list[fonction / formule / nappe],
◇ SANS_GROUP_NO = list[grno],
◇ ALGO_CONT = / "CONTRAINTE" (par défaut),
/ "PENALISATION",
# Si: equal_to("ALGO_CONT", 'PENALISATION')
◆ COEF_PENA = float,
),
# Si: equal_to("FORMULATION", 'DISCRETE') and equal_to("FROTTEMENT", 'COULOMB')
◆ ZONE = _F(
◇ APPARIEMENT = / "MAIT_ESCL" (par défaut),
/ "NODAL",
◇ GROUP_MA_MAIT = grma,
◇ GROUP_MA_ESCL = grma,
◇ NORMALE = / "ESCL",
/ "MAIT" (par défaut),
/ "MAIT_ESCL",
◇ VECT_MAIT = / "AUTO" (par défaut),
/ "FIXE",
/ "VECT_Y",
# Si: equal_to("VECT_MAIT", 'FIXE')
◆ MAIT_FIXE = list[float],
# Si: equal_to("VECT_MAIT", 'VECT_Y')
◆ MAIT_VECT_Y = list[float],
◇ VECT_ESCL = / "AUTO" (par défaut),
/ "FIXE",
/ "VECT_Y",
# Si: equal_to("VECT_ESCL", 'FIXE')
◆ ESCL_FIXE = list[float],
# Si: equal_to("VECT_ESCL", 'VECT_Y')
◆ ESCL_VECT_Y = list[float],
◇ TYPE_PROJECTION = / "FIXE",
/ "ORTHOGONALE" (par défaut),
# Si: equal_to("TYPE_PROJECTION", 'FIXE')
◇ DIRE_APPA = list[float],
◇ DIST_POUTRE = / "NON" (par défaut),
/ "OUI",
◇ DIST_COQUE = / "NON" (par défaut),
/ "OUI",
# Si: equal_to("DIST_POUTRE", 'OUI') or equal_to("DIST_COQUE", 'OUI')
◆ CARA_ELEM = cara_elem,
◇ DIST_MAIT = fonction / formule / nappe,
◇ DIST_ESCL = fonction / formule / nappe,
◇ DIST_APPA = float (défaut: -1.0),
◇ TOLE_PROJ_EXT = float (défaut: 0.5),
◇ SANS_GROUP_NO = list[grno],
◇ SANS_GROUP_MA = list[grma],
◇ RESOLUTION = / "NON",
/ "OUI" (par défaut),
# Si: equal_to("RESOLUTION", 'NON')
◇ TOLE_INTERP = float (défaut: 0.0),
◇ ALGO_CONT = / "CONTRAINTE" (par défaut),
/ "GCP",
/ "PENALISATION",
# Si: equal_to("ALGO_CONT", 'CONTRAINTE')
◇ GLISSIERE = / "NON" (par défaut),
/ "OUI",
# Si: equal_to("GLISSIERE", 'OUI')
◇ ALARME_JEU = float (défaut: 0.0),
# Si: equal_to("ALGO_CONT", 'PENALISATION')
◆ E_N = float,
◆ COULOMB = float,
◇ COEF_MATR_FROT = float (défaut: 0.0),
◇ ALGO_FROT = "PENALISATION",
◆ E_T = float,
),
# Si: equal_to("FORMULATION", 'DISCRETE') and not equal_to("FROTTEMENT", 'COULOMB')
◆ ZONE = _F(
◇ APPARIEMENT = / "MAIT_ESCL" (par défaut),
/ "NODAL",
◇ GROUP_MA_MAIT = grma,
◇ GROUP_MA_ESCL = grma,
◇ NORMALE = / "ESCL",
/ "MAIT" (par défaut),
/ "MAIT_ESCL",
◇ VECT_MAIT = / "AUTO" (par défaut),
/ "FIXE",
/ "VECT_Y",
# Si: equal_to("VECT_MAIT", 'FIXE')
◆ MAIT_FIXE = list[float],
# Si: equal_to("VECT_MAIT", 'VECT_Y')
◆ MAIT_VECT_Y = list[float],
◇ VECT_ESCL = / "AUTO" (par défaut),
/ "FIXE",
/ "VECT_Y",
# Si: equal_to("VECT_ESCL", 'FIXE')
◆ ESCL_FIXE = list[float],
# Si: equal_to("VECT_ESCL", 'VECT_Y')
◆ ESCL_VECT_Y = list[float],
◇ TYPE_PROJECTION = / "FIXE",
/ "ORTHOGONALE" (par défaut),
# Si: equal_to("TYPE_PROJECTION", 'FIXE')
◇ DIRE_APPA = list[float],
◇ DIST_POUTRE = / "NON" (par défaut),
/ "OUI",
◇ DIST_COQUE = / "NON" (par défaut),
/ "OUI",
# Si: equal_to("DIST_POUTRE", 'OUI') or equal_to("DIST_COQUE", 'OUI')
◆ CARA_ELEM = cara_elem,
◇ DIST_MAIT = fonction / formule / nappe,
◇ DIST_ESCL = fonction / formule / nappe,
◇ DIST_APPA = float (défaut: -1.0),
◇ TOLE_PROJ_EXT = float (défaut: 0.5),
◇ SANS_GROUP_NO = list[grno],
◇ SANS_GROUP_MA = list[grma],
◇ RESOLUTION = / "NON",
/ "OUI" (par défaut),
# Si: equal_to("RESOLUTION", 'NON')
◇ TOLE_INTERP = float (défaut: 0.0),
◇ ALGO_CONT = / "CONTRAINTE" (par défaut),
/ "GCP",
/ "PENALISATION",
# Si: equal_to("ALGO_CONT", 'CONTRAINTE')
◇ GLISSIERE = / "NON" (par défaut),
/ "OUI",
# Si: equal_to("GLISSIERE", 'OUI')
◇ ALARME_JEU = float (défaut: 0.0),
# Si: equal_to("ALGO_CONT", 'PENALISATION')
◆ E_N = float,
),
# Si: equal_to("FORMULATION", 'CONTINUE') and equal_to("FROTTEMENT", 'COULOMB')
◆ ZONE = _F(
◇ ALGO_CONT = / "LAC",
/ "PENALISATION",
/ "STANDARD" (par défaut),
◇ ALGO_FROT = / "PENALISATION",
/ "STANDARD" (par défaut),
# Si: equal_to("ALGO_FROT", 'STANDARD')
# Si: (equal_to("ALGO_CONT", 'PENALISATION') and equal_to("ALGO_FROT", 'STANDARD') )
◇ ADAPTATION = / "ADAPT_COEF",
/ "CYCLAGE" (par défaut),
/ "NON",
/ "TOUT",
◇ COEF_FROT = float (défaut: 100.0),
# Si: (equal_to("ADAPTATION", 'NON') or equal_to("ADAPTATION", 'CYCLAGE') or not exists("ADAPTATION"))
◆ COEF_PENA_CONT = float,
# Si: (equal_to("ADAPTATION", 'ADAPT_COEF') or equal_to("ADAPTATION", 'TOUT'))
◇ PENE_MAXI = float,
◇ COEF_PENA_CONT = float (défaut: 100.0),
# Si: (equal_to("ALGO_CONT", 'STANDARD') and equal_to("ALGO_FROT",'STANDARD' ) )
◇ ADAPTATION = / "ADAPT_COEF",
/ "CYCLAGE" (par défaut),
/ "NON",
/ "TOUT",
◇ COEF_CONT = float (défaut: 100.0),
◇ COEF_FROT = float (défaut: 100.0),
# Si: (equal_to("ALGO_CONT", 'PENALISATION') and equal_to("ALGO_FROT", 'PENALISATION'))
◇ ADAPTATION = / "ADAPT_COEF",
/ "CYCLAGE" (par défaut),
/ "NON",
/ "TOUT",
# Si: (equal_to("ADAPTATION", 'NON') or equal_to("ADAPTATION", 'CYCLAGE') or not exists("ADAPTATION"))
◆ COEF_PENA_CONT = float,
◆ COEF_PENA_FROT = float,
# Si: (equal_to("ADAPTATION", 'ADAPT_COEF') or equal_to("ADAPTATION", 'TOUT'))
◇ PENE_MAXI = float,
◇ COEF_PENA_CONT = float (défaut: 100.0),
◇ GLIS_MAXI = float,
◇ COEF_PENA_FROT = float (défaut: 10000000.0),
# Si: (equal_to("ALGO_CONT", 'STANDARD') and equal_to("ALGO_FROT", 'PENALISATION'))
◇ ADAPTATION = / "ADAPT_COEF",
/ "CYCLAGE" (par défaut),
/ "NON",
/ "TOUT",
◇ COEF_CONT = float (défaut: 100.0),
# Si: (equal_to("ADAPTATION", 'NON') or equal_to("ADAPTATION", 'CYCLAGE'))
◆ COEF_PENA_FROT = float,
# Si: (equal_to("ADAPTATION", 'ADAPT_COEF') or equal_to("ADAPTATION", 'TOUT'))
◇ GLIS_MAXI = float,
◇ COEF_PENA_FROT = float (défaut: 10000000.0),
# Si: equal_to("ALGO_CONT", 'STANDARD') or equal_to("ALGO_CONT", 'PENALISATION')
◇ APPARIEMENT = "MAIT_ESCL",
◇ GROUP_MA_MAIT = grma,
◇ GROUP_MA_ESCL = grma,
◇ NORMALE = / "ESCL",
/ "MAIT" (par défaut),
/ "MAIT_ESCL",
◇ VECT_MAIT = / "AUTO" (par défaut),
/ "FIXE",
/ "VECT_Y",
# Si: equal_to("VECT_MAIT", 'FIXE')
◆ MAIT_FIXE = list[float],
# Si: equal_to("VECT_MAIT", 'VECT_Y')
◆ MAIT_VECT_Y = list[float],
◇ VECT_ESCL = / "AUTO" (par défaut),
/ "FIXE",
/ "VECT_Y",
# Si: equal_to("VECT_ESCL", 'FIXE')
◆ ESCL_FIXE = list[float],
# Si: equal_to("VECT_ESCL", 'VECT_Y')
◆ ESCL_VECT_Y = list[float],
◇ TYPE_PROJECTION = / "FIXE",
/ "ORTHOGONALE" (par défaut),
# Si: equal_to("TYPE_PROJECTION", 'FIXE')
◇ DIRE_APPA = list[float],
◇ DIST_APPA = float (défaut: -1.0),
◇ TOLE_PROJ_EXT = float (défaut: 0.5),
◇ DIST_POUTRE = / "NON" (par défaut),
/ "OUI",
◇ DIST_COQUE = / "NON" (par défaut),
/ "OUI",
# Si: equal_to("DIST_POUTRE", 'OUI') or equal_to("DIST_COQUE", 'OUI')
◆ CARA_ELEM = cara_elem,
◇ DIST_MAIT = fonction / formule / nappe,
◇ DIST_ESCL = fonction / formule / nappe,
◇ SANS_GROUP_NO = list[grno],
◇ SANS_GROUP_MA = list[grma],
◇ INTEGRATION = / "AUTO" (par défaut),
/ "GAUSS",
/ "NCOTES",
/ "SIMPSON",
# Si: equal_to("INTEGRATION", 'GAUSS')
◇ ORDRE_INT = int (défaut: 3),
# Si: equal_to("INTEGRATION", 'SIMPSON')
◇ ORDRE_INT = int (défaut: 1),
# Si: equal_to("INTEGRATION", 'NCOTES')
◇ ORDRE_INT = int (défaut: 3),
◇ RESOLUTION = / "NON",
/ "OUI" (par défaut),
# Si: equal_to("RESOLUTION", 'NON')
◇ TOLE_INTERP = float (défaut: 0.0),
◇ CONTACT_INIT = / "INTERPENETRE" (par défaut),
/ "NON",
/ "OUI",
# Si: equal_to("CONTACT_INIT", 'INTERPENETRE')
◇ DIST_MAXI = float,
◇ GLISSIERE = / "NON" (par défaut),
/ "OUI",
# Si: equal_to("ALGO_CONT", 'LAC')
◇ APPARIEMENT = "MORTAR",
◇ TYPE_APPA = / "RAPIDE" (par défaut),
/ "ROBUSTE",
◇ RESI_APPA = float (défaut: 1e-08),
◇ TYPE_JACOBIEN = / "ACTUALISE",
/ "INITIAL" (par défaut),
◇ INTEGRATION = "AUTO",
◆ GROUP_MA_MAIT = grma,
◆ GROUP_MA_ESCL = grma,
◇ CONTACT_INIT = / "INTERPENETRE" (par défaut),
/ "NON",
/ "OUI",
# Si: equal_to("CONTACT_INIT", 'INTERPENETRE')
◇ DIST_MAXI = float,
◆ COULOMB = float,
◇ GRAND_GLIS = / "NON" (par défaut),
/ "OUI",
◇ SEUIL_INIT = float,
◇ SANS_GROUP_NO_FR = list[grno],
# Si: exists("SANS_GROUP_NO_FR")
◇ DIRE_EXCL_FROT = list[float],
),
# Si: equal_to("FORMULATION", 'CONTINUE') and not equal_to("FROTTEMENT", 'COULOMB')
◆ ZONE = _F(
◇ ALGO_CONT = / "LAC",
/ "PENALISATION",
/ "STANDARD" (par défaut),
# Si: equal_to("ALGO_CONT", 'STANDARD')
◇ COEF_CONT = float (défaut: 100.0),
◇ ADAPTATION = / "ADAPT_COEF",
/ "CYCLAGE" (par défaut),
/ "NON",
/ "TOUT",
# Si: equal_to("ALGO_CONT", 'PENALISATION')
◇ ADAPTATION = / "ADAPT_COEF",
/ "CYCLAGE" (par défaut),
/ "NON",
/ "TOUT",
# Si: (equal_to("ADAPTATION", 'ADAPT_COEF')) or (equal_to("ADAPTATION", 'TOUT'))
◇ PENE_MAXI = float,
◇ COEF_PENA_CONT = float (défaut: 100.0),
# Si: (equal_to("ADAPTATION", 'CYCLAGE')) or (equal_to("ADAPTATION", 'NON')) or (not exists("ADAPTATION"))
◆ COEF_PENA_CONT = float,
# Si: equal_to("ALGO_CONT", 'STANDARD') or equal_to("ALGO_CONT", 'PENALISATION')
◇ APPARIEMENT = "MAIT_ESCL",
◇ GROUP_MA_MAIT = grma,
◇ GROUP_MA_ESCL = grma,
◇ NORMALE = / "ESCL",
/ "MAIT" (par défaut),
/ "MAIT_ESCL",
◇ VECT_MAIT = / "AUTO" (par défaut),
/ "FIXE",
/ "VECT_Y",
# Si: equal_to("VECT_MAIT", 'FIXE')
◆ MAIT_FIXE = list[float],
# Si: equal_to("VECT_MAIT", 'VECT_Y')
◆ MAIT_VECT_Y = list[float],
◇ VECT_ESCL = / "AUTO" (par défaut),
/ "FIXE",
/ "VECT_Y",
# Si: equal_to("VECT_ESCL", 'FIXE')
◆ ESCL_FIXE = list[float],
# Si: equal_to("VECT_ESCL", 'VECT_Y')
◆ ESCL_VECT_Y = list[float],
◇ TYPE_PROJECTION = / "FIXE",
/ "ORTHOGONALE" (par défaut),
# Si: equal_to("TYPE_PROJECTION", 'FIXE')
◇ DIRE_APPA = list[float],
◇ DIST_APPA = float (défaut: -1.0),
◇ TOLE_PROJ_EXT = float (défaut: 0.5),
◇ DIST_POUTRE = / "NON" (par défaut),
/ "OUI",
◇ DIST_COQUE = / "NON" (par défaut),
/ "OUI",
# Si: equal_to("DIST_POUTRE", 'OUI') or equal_to("DIST_COQUE", 'OUI')
◆ CARA_ELEM = cara_elem,
◇ DIST_MAIT = fonction / formule / nappe,
◇ DIST_ESCL = fonction / formule / nappe,
◇ SANS_GROUP_NO = list[grno],
◇ SANS_GROUP_MA = list[grma],
◇ INTEGRATION = / "AUTO" (par défaut),
/ "GAUSS",
/ "NCOTES",
/ "SIMPSON",
# Si: equal_to("INTEGRATION", 'GAUSS')
◇ ORDRE_INT = int (défaut: 3),
# Si: equal_to("INTEGRATION", 'SIMPSON')
◇ ORDRE_INT = int (défaut: 1),
# Si: equal_to("INTEGRATION", 'NCOTES')
◇ ORDRE_INT = int (défaut: 3),
◇ RESOLUTION = / "NON",
/ "OUI" (par défaut),
# Si: equal_to("RESOLUTION", 'NON')
◇ TOLE_INTERP = float (défaut: 0.0),
◇ CONTACT_INIT = / "INTERPENETRE" (par défaut),
/ "NON",
/ "OUI",
# Si: equal_to("CONTACT_INIT", 'INTERPENETRE')
◇ DIST_MAXI = float,
◇ GLISSIERE = / "NON" (par défaut),
/ "OUI",
# Si: equal_to("ALGO_CONT", 'LAC')
◇ APPARIEMENT = "MORTAR",
◇ TYPE_APPA = / "RAPIDE" (par défaut),
/ "ROBUSTE",
◇ RESI_APPA = float (défaut: 1e-08),
◇ TYPE_JACOBIEN = / "ACTUALISE",
/ "INITIAL" (par défaut),
◇ INTEGRATION = "AUTO",
◆ GROUP_MA_MAIT = grma,
◆ GROUP_MA_ESCL = grma,
◇ CONTACT_INIT = / "INTERPENETRE" (par défaut),
/ "NON",
/ "OUI",
),
)
◆ : obligatoire
◇ : optionnel
⟐ : présent par défaut
& : ensemble
/ : un seul parmi
| : plusieurs choix possibles
Principes#
Cette commande permet de décrire les zones soumises à des conditions de contact unilatéral avec ou sans frottement. La description se fait à deux niveaux:
Les paramètres globaux comme le choix de la formulation ou les paramètres de contrôle de l’algorithme de résolution non-linéaire (boucles de point fixe ou de Newton, paramètres spécifiques pour le solveur);
Les paramètres locaux spécifiques à chaque zone de contact.
Le concept issu de DEFI_CONTACT est ensuite renseigné comme paramètre dans le mot-clef simple CONTACT des opérateurs [STAT_NON_LINE] et [DYNA_NON_LINE]. Chaque zone comprend deux surfaces pouvant entrer en contact qui sont décrites par la donnée des groupes de mailles qui les constituent. Pour le parallélisme, on conseille d’utiliser la méthode de partitionnement centralisé si l’on utilise la formulation discrète et/ou qu’on utilise [DYNA_NON_LINE] (à cause des schémas en temps).
Les ensembles de mailles potentiellement en contact sont des mailles de peau: surfaciques et linéiques en dimension 3 (QUAD9, QUAD8, QUAD4, TRIA7, TRIA6, TRIA3, SEG3, SEG2), linéiques et ponctuelles en dimension 2 (SEG3, SEG2 et POI1).
En dimension 2, les mailles de type POI1 doivent obligatoirement être sur la surface esclave. Elles ne sont pas utilisables avec la formulation CONTINUE.
En dimension 3, les mailles de type SEG2 ou SEG3 doivent obligatoirement être sur la surface esclave. Cela implique que la définition d’un contact entre deux éléments poutre n’est pas possible en 3D.
- Remarques
Pour la formulation
DISCRETE, en dimension 3, le traitement du contact avec des mailles de bord quadratiques de type QUAD8 nécessite de lier les nœuds milieux aux nœuds sommets de façon à avoir des résultats corrects. Cette opération est réalisée automatiquement dans le code. Néanmoins, pour les calculs 3D milieux continus l’utilisation d’éléments HEXA27 ou PENTA18 (à faces QUAD9) est fortement conseillée. Si toutefois l’utilisation d’éléments HEXA20 s’avère nécessaire, les relations linéaires écrites automatiquement à cette occasion peuvent être susceptibles d’entrer en conflit avec des conditions aux limites (en particulier de symétrie), c’est pourquoi il peut être nécessaire de n’imposer les conditions aux limites que sur les nœuds sommets des mailles QUAD8 concernées (on pourra utiliser l’opérateurDEFI_GROUPpour la création du groupe de nœuds ad-hoc).Pour la formulation
CONTINUE, en dimension 3, l’utilisation de mailles de bord quadratiques de type QUAD8 ou TRIA6 courbes (c’est-à-dire dont les nœuds milieux ne sont pas alignés avec les nœuds sommets) peut entraîner des violations de la loi de contact. Plus précisément le contact est alors résolu en moyenne sur chaque élément. En présence de contact on peut donc observer des jeux à la fois légèrement positifs et négatifs ce qui peut perturber les résultats proche de la zone de contact ou bien les calculs de reprise avec état initial. Pour cette raison, il est conseillé d’utiliser des éléments HEXA27 ou PENTA18 (à faces QUAD9) ou bien des éléments linéaires. On peut transformer en HEXA27 ou PENTA18 un maillage constitué de mailles HEXA20 ou PENTA15 à l’aide de l’opérateur [CREA_MAILLAGE].
Les structures étudiées peuvent subir de grands glissements l’une par rapport à l’autre. Il existe trois grands types de formulations:
Les formulations discrètes (voir [R5.03.50]) qui correspondent à la résolution du problème unilatéral discrétisé (inconnues de déplacements et forces nodales). Cette formulation est accessible via FORMULATION=”DISCRETE”. Elle est utilisable avec ou sans frottement de Coulomb.
La formulation continue (voir [R5.03.52]) qui est une méthode de lagrangien augmenté écrite à l’aide de l’écriture variationnelle mixte «déplacements / pression de contact / multiplicateurs de frottement». Cette formulation est accessible via FORMULATION=”CONTINUE”. Elle est utilisable avec ou sans frottement de Coulomb.
La formulation de type liaison unilatérale (FORMULATION=”LIAISON_UNIL”). Proche des formulations discrètes, elle s’appuie sur un algorithme utilisé en contact pour imposer des conditions aux limites de type inégalité sur n’importe quel degré de liberté. Cette formulation est traitée séparément dans la dernière partie de ce document ( cf. § 3.8 ).
Avant de faire un calcul avec contact, il est indispensable d’avoir lu la notice d’utilisation du contact [U2.04.04] qui explicite par des exemples le rôle de la plupart des mots-clés décrits ci-dessous et décrit des méthodologies pour différents types d’études avec prise en compte du contact.
Toutes les méthodes de résolution du contact-frottement dites formulations «maillées» (formulations discrètes [R5.03.50] ou formulation continue [R5.03.52]) reposent sur une stratégie en deux temps:
une opération d’appariement qui consiste à trouver quelles mailles et quels nœuds sont potentiellement en situation de contact;
une opération de résolution proprement dite qui consiste à résoudre le problème de contact unilatéral avec ou sans frottement.
Les paragraphes 3.1 et 3.2 se concentrent sur la phase d’appariement tandis que les paragraphes 3.4 et 3.5 traitent des méthodes de résolution du problème.
Enfin le paragraphe 3.6 décrit le champ dédié au post-traitement, produit par un calcul avec contact.
La formulation “LIAISON_UNIL” est abordée dans le paragraphe 3.8 .
Contrôle de l’appariement (méthodes maillées hors LAC)#
On utilise le mot-clef facteur ZONE. Les mots-clefs de ce paragraphe sont valables pour les formulations maillées (DISCRETE et CONTINUE), sauf pour la méthode LAC (voir § 3.3 ).
Opérande APPARIEMENT#
Dans le cas des formulations discrètes l’appariement peut être nœud-facette (`MAIT_ESCL’) ou nodal (`NODAL’). Pour l’appariement nodal on écrit une relation de non-pénétration entre un nœud maître et un nœud esclave, alors que pour l’appariement nœud-facette on écrit cette relation entre un nœud esclave et sa projection sur la maille maître la plus proche (voir [R5.03.50] pour des détails sur l’algorithme d’appariement).
L’appariement nodal est réservé aux maillages compatibles et n’est disponible qu’en formulation DISCRETE. L’appariement maître-esclave est la seule méthode à permettre de prendre en compte les grands glissements de façon précise.
Opérandes GROUP_MA_MAIT/GROUP_MA_ESCL#
Pour les formulations maillées l’utilisateur fournit la liste des mailles de contact potentielles de la surface maître (GROUP_MA_MAIT) et de la surface esclave (GROUP_MA_ESCL). Ces mailles doivent être surfaciques ou linéiques en dimension 3 (QUAD9, QUAD8, QUAD4, TRIA7, TRIA6, TRIA3, SEG3, SEG2), linéiques ou ponctuelles en dimension 2 (SEG3, SEG2 et POI1).
- Attention
Il est important de vérifier que la connectivité de ces mailles est telle que la normale à la structure est sortante(pour ce faire, utilisez [MODI_MAILLAGE]).
L’intersection entre surface esclave et maître d’une même zone doit être disjointe ou bien les nœuds communs doivent être exclus
Les surfaces esclaves doivent être impérativement deux à deux disjointes en formulation continue.
Dans toute la suite, on utilisera le concept maître-esclave: les nœuds de la surface esclave ne peuvent pas «pénétrer» dans les facettes (ou les nœuds) de la surface maître. Dans le cas de l’appariement de type MAIT_ESCL, la surface maître est celle définie par GROUP_MA_MAIT. Dans le cas de l’appariement de type NODAL(disponible uniquement pour les formulations discrètes), la surface maître est celle qui doit comporter le plus de nœuds. Si ce n’est pas le cas l’utilisateur est arrêté par un message d’erreur et invité à intervertir les deux surfaces.
- Remarques
Il est impossible de mélanger les modélisations purement bidimensionnelles (contraintes planes C_PLAN, déformations planes D_PLAN et axi-symétriques AXIS) avec les modélisations tri-dimensionnelles. Les surfaces maître et esclave doivent être de même nature (2D/2D ou 3D/3D). Un message d’erreur arrête l’utilisateur dans le cas contraire. Notons qu’une poutre, une plaque ou une coque sont de dimension 3 et qu’il est donc possible de faire du contact poutre/3D ou poutre/plaque.
En 3D, il n’est pas possible de définir des zones de contact avec une surface esclave de type SEG2 ou SEG3, ce qui exclut le cas d’un contact entre deux éléments de poutres ou de câbles.
Opérandes SANS_GROUP_NO/SANS_GROUP_MA#
Les opérandes SANS_GROUP_NO et SANS_GROUP_MA permettent d’exclure des nœuds des surfaces esclaves, opération qui est recommandée lorsque ces derniers sont soumis à des conditions aux limites dans la direction attendue du contact (encastrement par exemple).
Opérandes TYPE_PROJECTION/DIRE_APPA#
Le choix de la maille maître appariée à un nœud esclave se fait par une opération de minimisation de la distance entre ce nœud et les mailles maîtres. Avec l’option par défaut, TYPE_PROJECTION=”ORTHOGONALE”, l’algorithme utilisé pour cette projection orthogonale est un algorithme de Newton classique.
Dans de très rares cas cet algorithme peut échouer, par exemple si la projection sur une maille n’est pas unique, ce qui peut arriver si la maille maître est convexe. Dans ce cas, l’utilisateur peut renseigner une direction d’appariement fixe à utiliser dans l’algorithme via l’option TYPE_PROJECTION='FIXE', la direction étant alors donnée par un vecteur dans DIRE_APPA.
Opérandes DIST_APPA et TOLE_PROJ_EXT#
Lors de l’appariement du nœud esclave courant, il est possible de restreindre le domaine de recherche parmi les mailles maîtres avec l’utilisation du mot-clef DIST_APPA. Si DIST_APPA=-1 (valeur par défaut), alors toutes les mailles maîtres données dans la zone de contact sont susceptibles d’être appariées avec le nœud esclave. Si DIST_APPA=val avec val un réel positif, alors seules les mailles maîtres situées, en 3D dans la sphère, en 2D dans le cercle de rayon val centré(e) sur le nœud esclave peuvent être appariées.
Dans certaines situations, il peut être nécessaire d’étendre de manière fictive les mailles de la surface maître. Prenons le cas du contact en 2D sur la (les surfaces de contact sont donc des segments), on se place sur le bord de la surface de contact. La projection d’un nœud esclave tombe en dehors de la surface maître.
Fig. 110 Projection d’un nœud esclave en dehors d’une maille maître#
Une solution consiste alors à ne pas apparier le nœud, ce qui revient à l’exclure du contact:
Fig. 111 Exclusion d’un nœud esclave#
Cependant, cette solution ne tient pas compte des cas limites et peut provoquer des interpénétrations intempestives si jamais le maillage n’est pas «optimal» (c’est-à-dire pas assez fin, ce qui est difficile à assurer dans le cadre des grandes transformations). A contrario , on ne peut bien évidemment pas rabattre tous les nœuds se projetant en dehors de la surface maître.
On a donc opté pour une solution intermédiaire en limitant l’extension de la surface maître susceptible d’entraîner un rabattement.
Fig. 112 Fonctionnement de TOLE_PROJ_EXT#
La taille de la zone de rabattement est fixée par le mot-clef TOLE_PROJ_EXT qui prend pour argument la valeur, rapportée à l’élément de référence, de l’extension de la maille maître. Par défaut, cette valeur est fixée à 0,50. Par exemple en 2D, cela signifie que tout nœud esclave se projetant à plus de 25% à droite ou à gauche de la longueur de la maille maître ne sera pas rabattu (dans le cas d’un segment, l’élément de référence est de longueur 2. Pour interdire complètement le rabattement, il suffit de fixer TOLE_PROJ_EXT négatif. Cet opérateur est valable en 2D et en 3D (dans ce dernier cas, il s’agit de l’extension d’une maille surfacique de contact).
Remarque * Il est dangereux de désactiver complètement le rabattement. Hormis les bords des surfaces de contact, il existe en effet des situations où des points ne se projettent à l’intérieur d’aucune maille maître (c’est le cas pour toute surface maître convexe).Si tous les nœuds de contact venaient à être exclus, une alarme est émise. Il convient alors de vérifier que cette situation est bien celle attendue par l’utilisateur.
Choix des normales#
Type de normale (NORMALE)#
Il est possible de choisir le type de la normale utilisée pour écrire les conditions de non-interpénétration:
la normale extérieure à la maille maître (NORMALE=”MAIT”, par défaut);
la normale intérieure à la maille esclave (NORMALE=”ESCL”);
une moyenne entre les normales maître et esclave (NORMALE=”MAIT_ESCL”).
Détermination des normales maître ou esclave (VECT_MAIT/VECT_ESCL)#
La détermination de la normale (sur la maille esclave ou sur la maille maître) peut se faire de plusieurs manières:
automatiquement, la normale est alors calculée par l’utilisation des fonctions de forme de l’élément, c’est l’option “AUTO”;
fixe et donnée directement par l’utilisateur, c’est l’option “FIXE”. On entre alors la normale avec le mot-clef MAIT_FIXE ou ESCL_FIXE;
variable et donnée indirectement par la tangente, c’est l’option VECT_Y. L’utilisateur donne alors la direction du second vecteur tangent par le mot-clef MAIT_VECT_You ESCL_VECT_Y. Le code reconstitue alors la normale à partir du produit vectoriel de la première tangente de la maille et du vecteur fourni par l’utilisateur.
Une direction fixe (option VECT_*=”FIXE”) est nécessaire si on doit évaluer la normale sur une maille de type POI1.
Une direction variable donnée par la seconde tangente (VECT_MAIT=”VECT_Y”) est particulièrement utilisée dans le cas des poutres qui ne se déforment que dans un plan. Dans ce cas, l’utilisation de l’option de type VECT_Ypermet de réactualiser continûment la normale pendant que la poutre se déforme:
\(\vec{N}=\vec{T}\wedge \mathit{VECT}\text{\_}Y\)
Fig. 113 Détermination de la normale par VECT_Y#
Dans l’exemple ci-dessus, T1=(1,0,0)et T2=(-1,0,0), avec VECT_Y=(0,1,0), on obtient la normale souhaitée pour chaque poutre: N1=(0,0,1)et N2=(0,0,-1).
L’orientation de chaque poutre (c’est-à-dire les vecteurs T1 et T2) est donnée à l’aide du mot-clé ORIE_LIGNE de l’opérateur [MODI_MAILLAGE].
Lissage des normales (LISSAGE)#
L’opérande LISSAGE permet de lisser les normales aux surfaces de contact intervenant dans le calcul de la matrice de contact. On notera \(Q\) un nœud quelconque des surfaces de contact (maître ou esclave), \(P\) un nœud de la surface esclave et \(M\) le nœud maître obtenu par projection du nœud \(P\) .
Le lissage se fait en deux étapes:
la première étape du lissage consiste à effectuer une moyenne au nœud \(Q\) des normales aux mailles qui contiennent \(Q\) ;
la seconde étape consiste à interpoler la normale en \(P\) ou \(M\) à partir des normales en \(Q\) et des fonctions de forme associées à la maille contenant \(P\) ou \(M\) .
Le lissage prend en compte les options de normales décidées par les mots-clés VECT_MAIT et VECT_ESCL. Attention, ce paramètre est global et non pas zoné.
Modification du jeu#
Le jeu est toujours calculé comme étant la distance minimale entre le nœud esclave et la projection sur la maille maître la plus proche, modulo les options de choix de cette normale. Il est cependant possible de définir des valeurs de jeu «en dur», par exemple, pour simuler la présence d’un trou ou d’une bosse non représentée par le maillage, ou pour prendre en compte les caractéristiques géométriques des éléments de structure qui utilisent la notion de fibre neutre ou de surface moyenne.
Opérandes DIST_MAIT/DIST_ESCL#
Ces opérandes permettent de prendre en compte un jeu fictif non maillé ou bien l’épaisseur des coques par exemple (par défaut les relations de contact sont écrites entre les parties maillées c’est-à-dire entre les deux feuillets moyens).
Ce jeu est pris en compte sur les surfaces maîtres (DIST_MAIT) ou esclaves (DIST_ESCL). On compte la distance positivement dans le sens de la normale sortante à la structure (cf. [R5.03.50]). Une valeur négative permet donc de «creuser» virtuellement une surface (maître comme esclave). À l’inverse, une valeur positive permet de «grossir» une surface.
Les grandeurs renseignées sont nécessairement des fonctions des variables d’espace ou du temps (\(X,Y,Z,\mathit{INST}\) ). Si l’utilisateur désire une valeur fixe, il doit définir une fonction constante (voir [DEFI_CONSTANTE]).
Opérandes DIST_POUTRE/DIST_COQUE/CARA_ELEM#
Semblables aux deux mots-clés précédents, les mot-clefs DIST_POUTRE/DIST_COQUE permettent d’introduire un jeu fictif qui repose sur la description des éléments de structure dans le concept produit par AFFE_CARA_ELEM que l’utilisateur a obligatoirement renseigné:
pour les éléments de poutre (modélisation POU_*), le mot-clef DIST_POUTRE stipule que le code doit tenir compte d’un jeu supplémentaire correspondant au rayon de la section circulaire de la poutre.
pour les éléments de plaque ou de coque (modélisation DKTou COQUE_3Dpar exemple), le mot-clef DIST_COQUE stipule que le code doit tenir compte d’un jeu supplémentaire correspondant à la demi-épaisseur autour du feuillet moyen d’une coque.
Attention, lorsque l’on utilise ces mots-clefs, le jeu fictif n’est rajouté que sur la surface esclave. Si l’on modélise un contact entre deux éléments de structures, il faudra donc aussi utiliser DIST_MAIT.
Contrôle de l’appariement spécifique à la formulation CONTINUE#
Opérandes SANS_GROUP_NO_FR#
Ces mots-clefs permettent à l’utilisateur d’exclure du traitement du frottement des nœuds esclaves portant des conditions aux limites potentiellement en conflit avec l’imposition des conditions d’adhérence et de glissement. Les nœuds exclus continuent toutefois de vérifier les conditions de contact.
En 2D, aucun autre mot-clé n’est nécessaire: les nœuds sont exclus du frottement.
En 3D, si l’utilisateur a renseigné un vecteur à 3 composantes sous le mot-clé DIRE_EXCL_FROT alors la direction indiquée par la projection de ce vecteur sur le plan tangent aux points de contact est exclus. L’adhérence ou le glissement ne se produiront donc plus que dans la direction perpendiculaire (dans le plan tangent).
Si l’utilisateur ne renseigne pas le mot-clé DIRE_EXCL_FROT en 3D, alors cela revient à exclure les 2 directions orthogonales du frottement et donc à ne plus résoudre le frottement sur les nœuds éliminés.
- Remarque
L’exclusion de nœuds n’est possible qu’avec le schéma d’intégration par défaut
Contrôle spécifique à la formulation LAC#
On utilise le mot-clef facteur ZONE. Les mots-clefs de ce paragraphe sont valables pour la méthode LAC.
Opérandes GROUP_MA_MAIT/GROUP_MA_ESCL#
Pour la formulation LAC l’utilisateur fournit la liste des mailles de contact potentielles de la surface maître (GROUP_MA_MAIT) et de la surface esclave (GROUP_MA_ESCL). La surface esclave doit avoir été préalablement préparée (découpée en patchs) par la commande CREA_MAILLAGE/DECOUPE_LAC.
- Attention
Il est important de vérifier que la connectivité de ces mailles est telle que la normale à la structure est sortante(pour ce faire, utilisez [MODI_MAILLAGE]).
L’intersection entre surface esclave et maître d’une même zone doit être disjointe ou bien les nœuds communs doivent être exclus
Les surfaces esclaves doivent être impérativement deux à deux disjointes
Opérandes APPARIEMENT/TYPE_APPA#
La méthode LAC utilise obligatoirement un appariement de type «mortar», c’est-à-dire segment/segment (en 2D) ou face/face (en 3D). Cet appariement est beaucoup plus coûteux qu’un appariement de type noeud/segment utilisé pour les autres méthodes de contact. On a donc le choix entre deux possibilités:
Utiliser un algorithme rapide mais qui risque de provoquer des appariements faux (il est facile de contrôler ce problème visuellement). On choisit alors
TYPE_APPA = 'RAPIDE';Utiliser un algorithme robuste mais beaucoup plus lent. On choisit alors TYPE_APPA = “ROBUSTE;
On recommande de n’utiliser l’appariement «rapide» que pour les cas simples (surfaces connexes).
Le paramètre RESI_APPA permet de régler le degré de précision de l’appariement. Il n’est pas recommandé d’y toucher, son usage exige de grandes précautions et doit être réservé aux experts
Opérande TYPE_JACOBIEN#
Cet opérande est utilisé lorsque la cinématique du problème est de type «grandes transformations». Par exemple, si on fait une simulation avec le modèle «GDEF_LOG», il faut utiliser TYPE_JACOBIEN=”ACTUALISE” , sinon les résultats (en particuliers les pressions de contact) seront légèrement faux.
Opérande CONTACT_INIT#
L’opérande CONTACT_INIT permet de fixer le statut de contact à l’état initial.
Par défaut, seules les liaisons à jeu nul ou bien interpénétrées sont activées par l’algorithme (CONTACT_INIT=”INTERPENETRE”). Il est néanmoins possible de forcer l’algorithme à activer toutes les liaisons sans exception (CONTACT_INIT=”OUI”). La valeur CONTACT_INIT=”INTERPENETRE’est obligatoire en cas de reprise de calcul avec un état initial. Il est également possible de désactiver tout contact initial par CONTACT_INIT=”NON”.
La méthode LAC utilise une structure de données spécifique en sortie, CONT_ELEM, définie par élément .
Choix et contrôle de l’algorithme de résolution global#
Contrôle de la non-linéarité géométrique#
Quelle que soit la formulation employée, il est nécessaire de traiter la non-linéarité géométrique du problème de contact-frottement. Il est possible soit de la négliger (REAC_GEOM=”SANS”), soit de la résoudre de manière approchée (REAC_GEOM=”CONTROLE”) ou bien exactement (REAC_GEOM=”AUTOMATIQUE”).
Pour résoudre cette non-linéarité, on emploie en général un algorithme de type «point fixe» (ALGO_RESO_GEOM=”POINT_FIXE”). La formulation CONTINUE est aussi capable de traiter la non-linéarité géométrique au sein même de l’algorithme de Newton (ALGO_RESO_GEOM=”NEWTON”, voir § 3.4.4.5 ).
Lorsque la non-linéarité géométrique est résolue par une boucle de «point fixe», un certain nombre de réglages sont possibles.
L’opérande REAC_GEOM indique sur quelle configuration géométrique est traité le problème de contact:
REAC_GEOM=’AUTOMATIQUE’: on réactualise automatiquement la géométrie c’est-à-dire que le nombre de cycles «réactualisation géométrique-itérations» jusqu’à convergence n’est pas fixé par avance mais obéit à un critère de convergence géométrique. C’est l’option par défaut, conseillée pour résoudre correctement la non-linéarité d’appariement. Elle assure que les conditions de contact ont été imposées sur une configuration (initiale) qui diffère de moins de resi_geom de la configuration trouvée (1% par défaut pour les formulations DISCRETE ou CONTINUE).
REAC_GEOM=’SANS’: on travaille sur la géométrie initiale. Cette option n’est valable que dans l’hypothèse de petites perturbations ou quand la normale aux surfaces de contact ne change pas au cours du calcul.
REAC_GEOM=’CONTROLE’: lorsque le critère automatique ne parvient pas à être satisfait, l’utilisateur doit contrôler lui-même la réactualisation géométrique et pour cela il doit renseigner le paramètre NB_ITER_GEOM. C’est le nombre de cycles de réactualisations géométriques qui seront effectués par pas de charge. Plaçons-nous à un pas de charge donné:
La valeur 1 indique qu’à convergence de Newton, on réactualise la géométrie et on passe au pas de charge suivant.
La valeur 2 indique qu’à convergence de Newton, on réactualise la géométrie et on réitère jusqu’à convergence avant de passer au pas de charge suivant.
La valeur \(n>2\) indique que l’on fait \(n\) cycles «réactualisation géométrique-convergence» avant de passer au pas de charge suivant.
Si vous avez sélectionné REAC_GEOM=’AUTOMATIQUE’, le paramètre ITER_GEOM_MAXI est le nombre maximal toléré de cycles de réactualisations géométriques. Si le critère portant sur RESI_GEOM n’est pas satisfait au bout de iter_geom_maxi cycles, alors on s’arrête en erreur ou bien on découpe le pas de temps si l’utilisateur l’a demandé. La documentation [U2.04.04] fournit de nombreux conseils pour surmonter ces problèmes de convergence (en particulier, activer du lissage).
- Remarques
Si l’utilisateur choisit une réactualisation contrôlée avec \(n>1\) et qu’on détecte la nécessité d’une réactualisation géométrique, on émettra une alarme. Charge à l’utilisateur de décider si l’erreur commise (nécessairement supérieure à 1%) est acceptable ou non. Il y a en effet un risque d’erreur d’appariement (une maille a été appariée sur une configuration qui a bougé) et donc d’interpénétration.
Dans le cas où l’on résout sur la géométrie initiale ou bien avec un seul cycle de réactualisation géométrique, il n’y a pas d’avertissement car on ne peut pas calculer d’erreur. L’utilisateur doit donc vérifier la validité de son choix en post-traitement.
La valeur du critère de convergence géométrique est affichée dans le tableau des itérations de Newton (colonne CONTACT CRITERE VALEUR )
Frottement#
Pour affecter du frottement de Coulomb aux zones de contact, utilisez le mot-clef FROTTEMENT=”COULOMB”. Ce mot-clef est global (valable pour toutes les zones), mais il est possible d’affecter du frottement zone par zone en jouant sur la valeur du coefficient de Coulomb (on met ce coefficient à 0 quand on ne souhaite pas de frottement).
Formulation DISCRETE#
Choix des algorithmes#
Pour sélectionner le type d’algorithme dans la formulation DISCRETE, on utilise les mots-clefs ALGO_CONT et ALGO_FROT. ALGO_FROT est modifiable seulement si FROTTEMENT=”COULOMB”. Toutes les combinaisons ne sont pas possibles:
ALGO_FROT=”PENALISATION” |
|
ALGO_CONT=”CONTRAINTE” |
Impossible |
ALGO_CONT=”GCP” |
Impossible |
ALGO_CONT=”PENALISATION” |
OK |
Les différentes méthodes de résolution sont:
“CONTRAINTE”:algorithme par défaut qui traite le problème du contact unilatéral exact avec la méthode des contraintes actives (voir [R5.03.50]). Pas de frottement possible .
“GCP”: c’est une méthode itérative proche de la méthode ’CONTRAINTE’mais qui est particulièrement adaptée aux cas où le nombre de liaisons de contact est très élevé. Pas de frottement possible .
“PENALISATION”:la méthode pénalisée permet de traiter des problèmes de contact de manière approchée avec ou sans frottement, en 2D ou 3D.
Bien que les différents algorithmes soient donnés par zone, il n’est pas possible de mélanger plusieurs méthodes dans le même DEFI_CONTACT.
Méthodes dualisées (CONTRAINTE)#
La méthode CONTRAINTE permet de résoudre des problèmes de contact sans frottement de manière exacte (aucune interpénétration n’est tolérée). Elle est particulièrement rapide et robuste, sa convergence est prouvée. La résolution du système d’inéquations résultant du contact s’appuyant sur la construction explicite d’un complément de Schur, son utilisation est limitée à quelques centaines de liaisons de contact. Au-delà les coûts mémoire et calcul deviennent trop importants.
NB_RESOL est le nombre de résolutions simultanées pour la construction du complément de Schur. Réaliser plusieurs résolutions simultanées permet de manipuler des matrices par blocs. Augmenter nb_resol accélère donc la construction du complément de Schur mais fait perdre de la place mémoire. nb_resol=10 est un bon compromis. Ce paramètre est à réserver aux experts .
STOP_SINGULIER permet de désactiver l’erreur fatale apparaissant si le complément de Schur est singulier suite à une perte importante de décimales dans la factorisation (8 décimales par défaut). On renseigne pour cela STOP_SINGULIER=`NON’. Ce paramètre est à réserver aux experts .
On peut contrôler la boucle sur les statuts en donnant un coefficient multiplicateur, ITER_CONT_MULT : le nombre maximum d’itérations sur le statut de contact sera égal au produit iter_cont_multpar le nombre de nœuds esclaves.
Si le calcul s’arrête car le nombre maximum d’itérations de contact est dépassé, on peut alors tenter de raffiner le maillage, subdiviser le pas de temps ou en dernier recours augmenter la valeur de ITER_CONT_MULT.
Remarque: pour la méthode CONTRAINTE, la convergence étant prouvée, ce coefficient est fixé en dur à 2.
Méthode GLISSIERE#
Cette option est disponible uniquement pour la méthode CONTRAINTE. Elle permet d’activer le mode de contact bilatéral aussi appelé «glissière», dans lequel deux surfaces se trouvant en contact restent «collées» (c’est-à-dire avec un jeu nul) quel que soit l’évolution du chargement. Elle autorise de grands glissements relatifs.
Le contact bilatéral ne s’active qu’une fois que les surfaces sont effectivement en contact (on ne colle pas a priori deux surfaces séparées si le chargement ne l’implique pas).
L’opérande ALARME_JEU permet de déclencher une alarme dès que l’algorithme détecte que, sans la méthode glissière, il y aurait décollement des deux surfaces. Sa valeur est réglée par défaut à 0, ce qui alarme l’utilisateur dès que les surfaces auraient dû se décoller sans l’option activée.
Méthode GCP#
Cette méthode permet de résoudre des problèmes de contact sans frottement. Elle résout avec une précision réglable (éventuellement très élevée) les conditions de contact à l’aide de multiplicateurs de Lagrange. Elle est en tout point semblable à la méthode ’CONTRAINTE’ à la différence près qu’elle est de nature totalement itérative et donc très peu gourmande en mémoire. En d’autres termes, le surcoût de stockage lié à la prise en compte du contact est faible. Cette spécificité a pour effet de la rendre particulièrement adaptée aux cas impliquant un grand nombre de liaisons de contact.
Le mot-clé RESI_ABSO permet de régler la précision de la résolution des inéquations de contact (c’est un critère d’arrêt sur la valeur des jeux pour l’algorithme itératif). RESI_ABSO(qu’il faut comprendre par «résidu absolu») représente le niveau maximum d’interpénétration toléré pour les corps en contact. D’un point de vue pratique, on commencera par choisir une valeur de l’ordre de \({10}^{-3}\) fois la taille des éléments au voisinage des surfaces de contact puis on diminuera cette valeur jusqu’à stabilisation des résultats.
Le nombre maximum d’itérations autorisées de l’algorithme du gradient conjugué projeté peut être réglé avec le mot-clé ITER_GCP_MAXI. Par défaut ce nombre d’itérations dépend de la taille du problème.
Comme toute méthode de résolution itérative, la méthode “GCP’peut être accélérée par l’usage d’un pré-conditionneur. Un seul est aujourd’hui disponible: un pré-conditionneur de Dirichlet (PRE_COND='DIRICHLET'). Son usage peut dans certains cas accélérer et diminuer sensiblement le temps de résolution. Par défaut aucun pré-conditionneur n’est activé (PRE_COND='SANS').
La phase de pré-conditionnement est réalisée par la résolution (elle aussi itérative) d’un problème auxiliaire. Le mot clé COEF_RESI permet de ne déclencher ce pré-conditionneur que lorsque le résidu a suffisamment diminué: plus précisément lorsque le résidu initial de l’algorithme (c’est-à-dire l’interpénétration initiale) a été multipliée par coef_resi (coef_resi est donc plus petit que 1).
ITER_PRE_MAXI permet de fixer le nombre maximum d’itérations du pré-conditionneur.
La méthode de résolution GCP nécessite une phase appelée recherche linéaire. Deux variantes sont disponibles: admissible ou non-admissible. On les choisit avec le mot-clef RECH_LINEAIRE (cf.[R5.03.50]).
Méthode PENALISATION#
Cette méthode est une méthode de résolution du contact/frottement par régularisation. Elle est non exacte dans le sens où il y a toujours interpénétration lorsque le contact est établi. Si l’on utilise une formulation discrète avec pénalisation, il convient donc de renseigner le(s) coefficient(s) de pénalisation (cf § 3.5.1.1 ).
Formulation CONTINUE#
Choix des algorithmes#
La formulation continue dispose de deux types d’algorithmes pour résoudre les non-linéarités de contact-frottement: algorithme de point fixe ou bien algorithme de Newton généralisé. Outre la non-linéarité géométrique (cf. §), ce choix peut s’effectuer également pour la non-linéarité de contact et de frottement via les mots-clefs ALGO_RESO_CONT, ALGO_RESO_FROT et ALGO_RESO_GEOM (tous les choix ne sont pas possibles):
ALGO_RESO_CONT |
ALGO_RESO_FROT |
ALGO_RESO_GEOM |
|
POINT_FIXE |
POINT_FIXE |
POINT_FIXE |
OK |
NEWTON |
POINT_FIXE |
POINT_FIXE |
OK |
POINT_FIXE |
NEWTON |
POINT_FIXE |
OK |
NEWTON |
NEWTON |
POINT_FIXE |
OK (par défaut) |
POINT_FIXE |
POINT_FIXE |
NEWTON |
Impossible |
NEWTON |
POINT_FIXE |
NEWTON |
OK |
POINT_FIXE |
NEWTON |
NEWTON |
Impossible |
NEWTON |
NEWTON |
NEWTON |
OK |
Lorsque l’on choisit la méthode de Newton généralisée pour le frottement, la matrice tangente produite devient non-symétrique. La méthode de Newton généralisée est beaucoup plus rapide et moins sensible à la valeur du coefficient de frottement que la méthode de point fixe. Elle peut dans certains cas s’avérer moins robuste dans le traitement de la non-linéarité géométrique, c’est pourquoi elle n’est pas activée par défaut dans ce cas. Dans le cas de la résolution d’un problème de contact-frottement en Newton généralisé, il est souvent nécessaire d’augmenter le nombre d’itérations de Newton (fixé par défaut à 10).
Quelle que soit la méthode de résolution utilisée (point fixe ou Newton) les résultats obtenus sont identiques.
L’option MATR_DISTRIBUEE=’OUI’ du mot-clé facteur SOLVEUR des opérateurs non-linéaires est interdite avec le contact en formulation continue.
Non-linéarité de contact#
Avec les réglages par défaut (ALGO_RESO_CONT='NEWTON'), il n’y a aucun paramètre à fournir pour la résolution de la non-linéarité de contact.
Quand on choisit ALGO_RESO_CONT=”POINT_FIXE”, on peut contrôler la boucle sur les statuts de contact de deux manières:
En donnant le nombre absolu maximum d’itérations de contact, ITER_CONT_TYPE=”MAXI’puis ITER_CONT_MAXI;
En donnant le nombre relatif maximum d’itérations de contact par un coefficient multiplicateur, ITER_CONT_TYPE=”MULT’puis ITER_CONT_MULT; dans ce cas, le nombre d’itérations sur le statut de contact sera égal au produit iter_cont_multpar le nombre de nœuds esclaves.
En méthode de point fixe, les statuts sont changés par blocs et le nombre maximum d’itérations est donc plus logiquement renseigné en valeur absolue. Si le nombre maximum d’itérations de contact est atteint, on peut alors tenter de raffiner le maillage, subdiviser le pas de temps ou en dernier recours augmenter la valeur de ITER_CONT_MAXI/ITER_CONT_MULT.
Stabilisation des statut de contact avec matrice élastique#
Le mot-clé CONT_STAT_ELAS permet d’activer l’utilisation de la matrice élastique (même si MATRICE =«TANGENTE» sous NEWTON dans STAT_NON_LINE) lors des itérations de la phase de correction de l’algorithme de newton jusqu’à ce que les statuts de contact soit stabilisés pendant cont_stat_elas itérations. Par défaut, cette fonctionnalité est non active, cont_stat_elas=0. L’utilisation de cette fonctionnalité peut être utile lors de modélisation du contact avec des comportement snon-linéaires et que l’on observe des échecs d’intégration de la loi de comportement lors de la stabilisation des statuts.
Non-linéarité de seuil de frottement#
Par défaut le problème de Coulomb est résolu par un algorithme de Newton généralisé (ALGO_RESO_FROT=”NEWTON”), le seul mot-clé que l’on peut renseigner est donc RESI_FROT pour définir le critère de stationnarité du seuil (pendant de RESI_GEOM, cf. 3.4.1 ). Une colonne supplémentaire dans le tableau de convergence permet de suivre la valeur du critère (colonne CONTACT NEWTON GENE CRIT. FROT. ).
Quand on choisit ALGO_RESO_FROT=”POINT_FIXE”, le problème de Coulomb est résolu par une succession de points fixes sur le seuil de Tresca. Pour contrôler cette boucle, le mécanisme est le même que sur la boucle de réactualisation géométrique ( cf. 3.4.1 , ITER_FROT_MAXI joue le rôle de ITER_GEOM_MAXI et RESI_FROT joue le rôle de RESI_GEOM).
Quand on choisit ADAPTATION=ADAPT_COEF, on active la possibilité de contrôler le coefficient d’augmentation de frottement (COEF_FROT) par une méthode de traitement automatique des cyclages (voir [R5.03.52]). Cette option est à activer en cas de difficultés de convergence si on utilise la méthode de Newton généralisé, dans le cas où un grand nombre de cyclages se produit. Le nombre de cyclages au cours d’une itération est indiqué dans la colonne CONTACT INFOS CYCLAGES du tableau de convergence.
Non-linéarité géométrique#
Les paramètres de la boucle de point fixe sur la géométrie (paramètre par défaut) sont donnés dans le § 3.4.1 .
Quand on choisit ALGO_RESO_GEOM=”NEWTON”, on bascule vers l’algorithme de Newton généralisé. La non-linéarité géométriqueest alors prise en compte à chaque itération de Newton: on refait l’appariement et on recalculela base locale (normaleet tangentes). Dans ce mode, une colonne supplémentaire apparaît dans le tableau de convergence, elle correspond à l’évaluation du critère géométrique (colonne CONTACT NEWTON GENE CRIT. GEOM. ).
Il est possible de modifier la valeur cible de ce critère, tout comme dans le mode POINT_FIXE, à l’aide du paramètre RESI_GEOM. Toutefois sa définition en Newton généralisé implique qu’il est généralement vérifié avant le critère d’équilibre de Newton. Si on veut réellement le contrôler, il faut donc basculer en mode POINT_FIXE.
Méthode sans résolution#
Dans le cas du mode sans résolution (voir § 3.5.4 ) le code émet une alarme dès qu’il détecte une interpénétration. Le paramètre STOP_INTERP permet d’arrêter le calcul au lieu d’alarmer l’utilisateur.
Paramètres locaux (zone par zone) de contrôle de la résolution#
Paramètres locaux (zone par zone) de la formulation DISCRETE#
Les mots-clefs de ce paragraphe sont valables pour la formulation DISCRETE. Les paramètres sont définis par le mot-clef facteur ZONE.
Méthode “PENALISATION”#
E_N donne le coefficient de pénalisation sur l’interpénétration pour la méthode pénalisée. Il est homogène à un rapport de force par longueur: c’est la raideur de ressorts placés entre les surfaces de contact pour empêcher l’interpénétration. Une valeur de l’ordre du plus grand module de Young des solides en contact multipliée par une longueur caractéristique est initialement recommandée. On augmentera la valeur du coefficient jusqu’à l’obtention de résultats stables.
En outre il est possible de contrôler les distances d’interpénétration et donc d’affiner son choix de coefficient, ce qui n’est pas le cas en présence de frottement, puisque l’on ne sait pas a priori quelles sont les zones glissantes et non glissantes alors qu’en cas de contact on peut vérifier que les distances d’interpénétration sont petites devant les dimensions caractéristiques des zones de contact.
Il existe en formulation DISCRETE un mécanisme d’adaptation automatique du coefficient de pénalisation E_N ( voir la commande [DEFI_LIST_INST]).
E_T donne le coefficient de pénalisation sur le glissement pour la méthode pénalisée. Il est homogène à un rapport de force par longueur. Il n’est nécessaire que lorsque le contact est actif. Il faut augmenter la valeur de ce coefficient jusqu’à l’obtention de résultats stables, c’est-à-dire qui en dépendent le moins possible.
Paramètres spécifiques pour le frottement#
Le paramètre COULOMB permet de régler le coefficient de frottement.
Dans le cas d’une formulation pénalisée, le paramètre COEF_MATR_FROT, compris entre 0 et 1, permet de modérer l’effet déstabilisant de la partie négative de la matrice de glissement (qui est ajoutée à la rigidité tangente, cf. [R5.03.50]). Plus ce coefficient est grand, meilleure est la convergence lorsque l’on est proche de l’équilibre et plus la résolution est difficile loin de l’équilibre. Une valeur de 0.5 est donc un bon compromis. La valeur par défaut fixée à 0 assure une meilleure robustesse pour un temps de calcul plus long.
Paramètres locaux (zone par zone) de la formulation CONTINUE#
Les mots-clefs de ce paragraphe sont valables pour la formulation CONTINUE. Les paramètres sont définis par zone.
Opérandes CONTACT_INIT/SEUIL_INIT#
Les opérandes CONTACT_INIT et SEUIL_INIT permettent de fixer respectivement le statut de contact à l’état initial et le seuil de glissement initial.
Par défaut, seules les liaisons à jeu nul ou bien interpénétrées sont activées par l’algorithme (CONTACT_INIT=”INTERPENETRE”). Il est néanmoins possible de forcer l’algorithme à activer toutes les liaisons sans exception (CONTACT_INIT=”OUI”). La valeur CONTACT_INIT=”INTERPENETRE” est obligatoire en cas de reprise de calcul avec un état initial. Il est également possible de désactiver tout contact initial par CONTACT_INIT=”NON”.
La valeur par défaut pour détecter l’interpénétration est donnée par la formule suivante:
où \(ar_{min}\) est l’arête minimale calculée sur la zone du contact.
On peut aussi donner une valeur absolue à ce critère par le mot-clef DIST_MAXI.
S’agissant du frottement, l’utilisateur peut préciser, s’il le souhaite, la valeur du seuil initial frotInit par le mot-clef SEUIL_INIT (s’il désire un contact adhérent initial par exemple). Le seuil de glissement a la dimension d’une densité de force surfacique. En un point de la surface de contact, il y aura glissement si la pression de contact \(\lambda\) et le coefficient de frottement \(\mu\) vérifient: \(\lambda \ge \mu \times frotInit\) . La valeur qu’il aura choisie s’appliquera à tous les points de la zone de contact concernée. Si aucune valeur n’est renseignée alors le comportement par défaut de SEUIL_INIT est tel que:
s’il s’agit d’une reprise de calcul ou d’un calcul avec état initial, alors on reconstruit automatiquement le champ de seuil initial de chaque point de contact en utilisant les valeurs de la composante LAGS_C du champ DEPLprécisé dans STAT_NON_LINE/ETAT_INIT,
dans le cas contraire, le seuil initial est mis à zéro et tous les points sont potentiellement glissants.
Coefficients de la formulation CONTINUE#
La formulation continue est une formulation lagrangienne augmentée. Il en existe une version pénalisée.
Si on choisit ALGO_CONT=”STANDARD” et ALGO_FROT=”STANDARD”, la formulation continue est alors équivalente à une formulation lagrangienne augmentée classique dont les coefficients d’augmentation sont donnés, respectivement, par COEF_CONT et COEF_FROT.
Si on choisit ALGO_CONT=”PENALISATION” et ALGO_FROT=”PENALISATION”, la formulation est alors un Lagrangien pénalisé. On peut alors modifier les coefficients de pénalisation COEF_PENA_CONT et COEF_PENA_FROT mais seulement lorsqu’on choisit ADAPTATION=”NON” ou ADAPTATION=”CYCLAGE”.
Dans le cas où l’on souhaite utiliserle mode automatique de pénalisation ADAPTATION=”TOUT” ou ADAPTATION=”ADAPT_COEF”, on ne se préoccupe plus du choix de COEF_PENA_CONT mais uniquement de PENE_MAXI. Si PENE_MAXI n’est pas précisé, alors par défaut PENE_MAXI est égal à \(1.0\phantom{\rule{2em}{0ex}}{10}^{-2}\) fois la plus petite valeur d’arêtedans la zone de contact. La valeur maximale de pénétration sur l’ensemble des zones de contact est renseignée dans la colonne “”CONTACT PENETRATION””. Cela indique la qualité de traitement dû à la méthode pénalisée.
On peut également utiliser des modes mixtes ALGO_CONT=”STANDARD” et ALGO_FROT=”PENALISATION” et inversement.
La méthode pénalisée est décrite dans le cas de la méthode discrète aux § 3.4.3.5 et § 3.5.1.1 , COEF_PENA_CONT y correspond à E_N et COEF_PENA_FROT à E_T.
Opérande ADAPTATION#
L’opérande ADAPTATION permet de sélectionner une méthode de traitement des cas de convergence difficile pour le contact:
“NON”: il n’y a pas de traitement;
“ADAPT_COEF”: on automatise le calcul de COEF_PENA_CONT et/ou COEF_PENA_FROT;
“CYCLAGE”: les changements fréquents de statuts de contact peuvent rendre la convergence difficile. Pour éviter ces changements de statuts intempestifs (on parle de «cyclage»), on modifie le calcul des matrices de contact et de frottement. La matrice de contact devient une combinaison convexe entre les matrices de l’état (pression, jeu, statut) du point de contact cyclant à l’itération précédente et à l’itération courante. Ce mode est disponible pour ALGO_CONT=”STANDARD”/”PENALISATION”/”LAC”. De plus, dans ce mode, un basculement automatique et définitif entre le mode ALGO_CONT=”STANDARD’et le mode ALGO_CONT=”PENALISATION” peut survenir si les statuts de contact ne convergent pas bien. Dans ce cas, il y aura contrôle automatique de la pénétration maximum (mot-clef PENE_MAXI);
“TOUT”: on combine le mode “CYCLAGE’avec le mode “ADAPT_COEF” ;
Opérande INTEGRATION#
L’opérande `INTEGRATION’ permet de sélectionner une méthode d’intégration numérique pour les termes de contact et de frottement. Plusieurs méthodes sont implémentées:
`AUTO’ pour laisser le code choisir le schéma d’intégration le plus adapté (de type trapèze ou Simpson);
`GAUSS’ pour une quadrature de Gauss avec la possibilité de choisir le degré des polynômes que le schéma permet d’intégrer exactement;
SIMPSON’ pour un schéma de Simpson (:math:`1/3 ) avec la possibilité de choisir le nombre de subdivisions de l’élément de référence;
`NCOTES’ pour un schéma de Newton-Cotes avec la possibilité de choisir le degré des polynômes interpolateurs.
Le choix du degré des polynômes que l’on intègre exactement ou du nombre de subdivisions pour le schéma de Simpson se fait avec le mot-clé ORDRE_INT.
L’intégration automatique (choix par défaut) est la plus générale et la plus efficace. Le choix d’un schéma d’intégration est à réserver aux experts .
Opérande GLISSIERE#
Contrairement à la formulation discrète (voir § 3.4.3.3 ), il est possible d’activer cette option zone par zone.
Méthode sans résolution#
Quand RESOLUTION=”NON”, on réalise un contrôle de l’interpénétration de deux surfaces sans imposer les conditions de contact (s’il y a interpénétration, elle ne sera pas corrigée).
Le code émet une alarme dès qu’une interpénétration est détectée à la fin d’un pas de chargement. Le paramètre global STOP_INTERP (§ 3.4.6 ) permet d’arrêter le calcul au lieu d’alarmer l’utilisateur.
TOLE_INTERP (zone par zone) règle la valeur d’interpénétration tolérée (homogène à une longueur dans l’unité du maillage). La valeur donnée est absolue (n’a pas de signe). Cette méthode est disponible en formulation discrète et continue.
- Remarques
En mode RESOLUTION=”NON”, l’appariement n’est fait qu’une fois à la fin de chaque pas de temps, la notion de boucle géométrique n’existe plus si toutes les zones sont en mode RESOLUTION=”NON”. Dans ce dernier cas, l’option REAC_GEOM si elle est différente de “SANS” n’a donc pas de sens.
Le fait que le mode RESOLUTION=”NON” détecte des interpénétrations dans une des zones de contact ne préjuge pas que le calcul réel (avec vérification effective de la condition unilatérale) donne les mêmes résultats. En effet, l’activation de la condition unilatérale va nécessairement changer la cinématique de déformation par rapport au mode RESOLUTION=”NON”. Il convient donc d’être prudent lorsque l’on mélange des zones avec résolution du contact et d’autres sans résolution.
Les nœuds interpénétrés dans ce mode ont le statut CONT=3 dans le champ CONT_NOEU
Champ CONT_NOEU#
Pour faciliter le post-traitement, le champ CONT_NOEU est produit systématiquement à l’issue d’un calcul avec contact et il est disponible dans la structure de données résultat (de type evol_noli). Il contient les composantes suivantes définies en chaque nœud esclave:
CONT: indicateur de contact frottant
-1: le nœud (ou le point d’intégration) n’est pas apparié (par exemple hors de la maille maître, voir TOLE_PROJ_EXT)
0: pas de contact
1: contact adhérent (uniquement si FROTTEMENT=”COULOMB”)
2: contact glissant
3 : s’il y a interpénétration (uniquement en mode RESOLUTION=”NON” );
JEU: valeur du jeu
RN: norme de la réaction normale de contact
RNX: composante suivant \(\mathit{DX}\) de la réaction normale de contact
RNY: composante suivant \(\mathit{DY}\) de la réaction normale de contact
RNZ: composante suivant \(\mathit{DZ}\) de la réaction normale de contact
GLIX: composante suivant \({t}_{1}\) du glissement tangentiel (repère local)
GLIY: composante suivant \({t}_{2}\) du glissement tangentiel (repère local)
GLI: norme du glissement tangentiel
RTAX: composante suivant \(\mathit{DX}\) de la force tangentielle d’adhérence
RTAY: composante suivant \(\mathit{DY}\) de la force tangentielle d’adhérence
RTAZ: composante suivant \(\mathit{DZ}\) de la force tangentielle d’adhérence
RTGX: composante suivant \(\mathit{DX}\) de la force tangentielle de glissement
RTGY: composante suivant \(\mathit{DY}\) de la force tangentielle de glissement
RTGZ: composante suivant \(\mathit{DZ}\) de la force tangentielle de glissement
RX: composante suivant \(\mathit{DX}\) de la force de contact frottant (RNX+RTAX+RTGX)
RY: composante suivant \(\mathit{DY}\) de la force de contact frottant (RNY+RTAY+RTGY)
RZ: composante suivant \(\mathit{DZ}\) de la force de contact frottant (RNZ+RTAZ+RTGZ)
R: norme de la force de contact frottant
I: percussion de la résultante \(R\) de la force de contact frottant
IX: percussion de la composante suivant \(\mathit{DX}\) de la force de contact frottant
IY: percussion de la composante suivant \(\mathit{DY}\) de la force de contact frottant
IZ: percussion de la composante suivant \(\mathit{DZ}\) de la force de contact frottant
PROJ_X: coordonnées suivant \(\mathit{DX}\) de la projection du nœud esclave sur la maille ou le nœud maître
PROJ_Y: coordonnées suivant \(\mathit{DY}\) de la projection du nœud esclave sur la maille ou le nœud maître
PROJ_Z:coordonnées suivant \(\mathit{DZ}\) de la projection du nœud esclave sur la maille ou le nœud maître
- Remarque
En formulation CONTINUE ce champ n’est produit qu’avec le schéma d’intégration par défaut
Elle s’imprime comme suit sous forme de table:
MATABLE=POST_RELEVE_T(
ACTION=_F(INTITULE='INFOS FROTTEMENT',
GROUP_NO='ESCLAVE',
RESULTAT=U,
INST=10.,
TOUT_CMP='OUI',
NOM_CHAM='CONT_NOEU',
OPERATION='EXTRACTION',),)
IMPR_TABLE(TABLE=MATABLE);
Il convient de remarquer que les quantités correspondant aux réactions de contact-frottement sont des efforts nodaux (en unité de force) au sens des éléments finis et non des pressions de contact. En modélisation axisymétrique, tout comme pour l’option FORC_NODA ou REAC_NODA, il faut donc multiplier les valeurs obtenues par \(2\pi\) pour obtenir la résultante ( commande [CALC_CHAMP]). Les forces nodales n’ont pas de sens ponctuellement (elles dépendent de la finesse du maillage), seule leur résultante peut être interprétée.
Plus généralement, pour avoir accès aux pressions de contact, on se reportera à la notice d’utilisation du contact [U2.04.04] qui décrit les manières de les récupérer lorsqu’elles sont produites par le calcul ou de les reconstruire dans le cas contraire.
Champ CONT_ELEM#
Pour le post-traitement de la méthode LAC, le champ CONT_ELEM est produit systématiquement à l’issue d’un calcul avec contact. Il est disponible dans la structure de données résultat (de type evol_noli) et contient les composantes suivantes, définies en chaque maille esclave:
PRES :valeur de la pression moyenne de contact
JEU: valeur du jeu intégré (il est négatif si le nœud n’est pas apparié, positif ou nul dans le cas contraire)
CONT : indicateur de contact
-1: la maille n’est pas appariée
0: pas de contact
1: contact
COEFSURF: surface d’intersection. Cette valeur comprise entre 0 et 1 indique la portion de la maille esclave qui est effectivement intersectée par les mailles maîtres.
PRESCOOR: produit de COEFSURF et de PRES
Formulation LIAISON_UNIL#
La formulation LIAISON_UNIL est utilisable pour définir une condition unilatérale (inéquation) de type nodal sur des degrés de liberté quelconques tel que:
\(\sum{\alpha}_{i}(t){p}_{i}<r(x,y,z,t)\)
avec:
\({p}_{i}\) la valeur du degré de liberté d’un nœud (déplacement, pression, température, etc …) (§ 3.8.1.3 )
\({\alpha}_{i}(t)\) une fonction réelle du temps (paramètre INST) (§ 3.8.1.4 )
\(r(x,y,z,t)\) une fonction réelle du temps ou de l’espace (paramètres X, Y, Z, INST) (§ 3.8.1.4 )
On remarquera que le paramètre \({\alpha}_{i}\) permet aussi, si son signe est négatif, d’inverser le sens de l’inégalité.
Paramètres locaux (zone par zone) de la formulation LIAISON_UNIL#
Les mots-clefs de ce paragraphe sont valables pour la formulation LIAISON_UNIL. Les paramètres sont définis par zone.
Opérandes GROUP_MA/GROUP_NO#
La condition unilatérale s’exprime sur les nœuds du maillage donnés sous le mot-clef GROUP_NO. On peut néanmoins donner les mailles portant les nœuds grâce au mot-clef GROUP_MA. Contrairement au cas du contact «classique», comme les conditions sont nodales, il est inutile d’orienter les normales aux mailles de peau dans le cas LIAISON_UNIL.
Opérandes SANS_GROUP_NO#
Le mot-clef SANS_GROUP_NO permet d’exclure des nœuds de la condition unilatérale de la même manière que pour les formulations CONTINUE ou DISCRETE (voir § 3.1.3 ).
Opérande NOM_CMP#
NOM_CMP donne la liste des composantes \({p}_{i}\) (degrés de liberté) sur lesquelles s’exerce la relation unilatérale. Ce peut être n’importe quel degré de liberté porté par le nœud. Par exemple: PRE, PRE1, PRE2, TEMP ou encore DX, DY ou DZ.
Opérandes COEF_IMPO et COEF_MULT#
COEF_IMPO est la valeur \(r(t)\) imposée au membre de droite de la relation unilatérale. COEF_MULT est la liste des coefficients multiplicateurs \(\alpha (t)\) utilisés devant chacun des degrés de liberté. Les longueurs des listes COEF_MULT et NOM_CMP doivent bien entendu être identiques.
Les coefficients \(r(t)\) et \(\alpha (t)\) sont forcément des fonctions . Pour définir des coefficients constants, il conviendra d’utiliser la commande DEFI_CONSTANTE.
Opérandes ALGO_CONT et COEF_PENA#
Par défaut, la condition de liaison unilatérale est imposéeen utilisant la méthode des contraintes actives. Cette méthode supposeque la matrice globale soit symétrique. Dans le cas où la physique du problème conduit à une matrice non symétrique, la matrice globale est alors symétrisée et cela peut conduire à des difficultés de convergence.
Dans le cas où l’on souhaite conserver la non symétrie de la matrice globale lors de la résolution, on peututiliser la méthode de pénalisation. Lecoefficient de pénalisation COEF_PENA doitalors être renseigné. Une bonne valeur du coefficient COEF_PENA est difficile à déterminer de façon systématique. Cela dépend du problème et de la physique considérés. On ne peut pas donner de conseils généraux sur la valeur de ce paramètre, il est donc fortement conseillé à l’utilisateur de vérifier a posteriori que la condition unilatérale est correctement prise en compte en visualisant les résultats dans la zone concernée. Si ce n’est pas le cas, il est nécessaire d’augmenter COEF_PENA jusqu’à ce que cela se vérifie.
Exemple#
On veut imposer la condition 1.3*PRE1-5.2*PRE2 < 4.0, on aura alors:
coef_i = DEFI_CONSTANTE(VALE=4.0)
coef_m1 = DEFI_CONSTANTE(VALE=1.3)
coef_m2 = DEFI_CONSTANTE(VALE=-5.2)
NOM_CMP = (`PRE1’,’PRE2’)
COEF_IMPO = coef_i
COEF_MULT = (coef_m1,coef_m2)