u2.01.11 Notice d’utilisation de la manipulation de champs et de tables#
Résumé:
L’objectif de ce document est de fournir à l’utilisateur quelques recettes liées à la manipulation des champs ou des tables.
Dans ce document sont décrits les cas de manipulation des champs suivants:
Poursuivre un calcul STAT_NON_LINE après avoir retiré ou ajouté des éléments dans le modèle (ex: creusement d’un tunnel, mise en place des couches d’un barrage);
Définir un état de contraintes initiales (ou de variables internes) à partir de «formules analytiques»;
Appliquer une pression sur une partie (non prévue dans le maillage) du bord d’une structure 3D;
Calculer l’intégrale des contraintes ou d’une quantité dérivée sur le bord d’une structure 3D;
Relire un champ constant par éléments et le projeter aux nœuds du maillage.
Et pour les tables:
Évaluer un amortissement sur les fréquences propres calculées.
Comment appliquer une pression sur une partie restreinte (non maillée exactement) du bord d’une structure 3D#
Il est possible avec Code_Aster d’affecter un champ de pression sur une zone géométrique de la pièce à calculer non nécessairement maillée. En effet, il suffit de créer le maillage de peau support de la zone de pression, d’y créer un champ de pression qu’on projette sur le maillage de la pièce. La mise en donnée est alors semblable à la récupération / projection d’un champ de pression calculé par un code de CFD.
Dans l’exemple ci-dessous, on veut affecter une pression sur une zone circulaire centrée sur une face d’un cube, uniformément maillé en HEXA8. Le maillage du disque est réalisé à part.
Remarque :
On vérifie la valeur de la résultante totale d’effort par un calcul de l’intégrale de pression sur les zones affectées. En effet, l’opération de projection induit une perte (proportionnelle à la grossièreté du maillage) qu’il convient de mesurer.
Nous allons nous intéresser à la création de la charge CHA_PROJ *.* Les différentes étapes sont les suivantes:
lecture du maillage (disque) porteur de l’effort de pression;
création du champ de pression sur le disque;
projection du champ de pression depuis le disque vers la structure calculée;
création de la charge.
Nous allons détailler chacune de ces étapes.
Étape 1 : création du champ de pression sur le disque#
Création d’un champ de pression constant par élément
VAL =CREA_CHAMP( TYPE_CHAM = 'ELEM_PRES_R',
OPERATION = “AFFE”, MODELE = modele2, PROL_ZERO = “OUI”, AFFE =_F( GROUP_MA = “disque”, NOM_CMP = “PRES”, VALE = 100000000. ), …)
Création d’un résultat de type EVOL_CHAR à partir de ce champ
RES_PRES=CREA_RESU(OPERATION = 'AFFE',
TYPE_RESU = 'EVOL_CHAR',
NOM_CHAM = 'PRES',
AFFE = _F(CHAM_GD = VAL ,
MODELE = modele2,
INST = 0. ), )
Étape 2 : projection du champ de pression depuis le disque vers la structure calculée#
RES_PROJ=PROJ_CHAMP(METHODE='COLLOCATION',
RESULTAT=RES_PRES,
MODELE_1=modele2,
MODELE_2=MODE,
DISTANCE_MAX=1.,
CAS_FIGURE='2.5D',
PROL_ZERO='OUI',
VIS_A_VIS=_F(GROUP_MA_1='disque',
GROUP_MA_2='Group_1',),
TOUT_ORDRE='OUI',);
Étape 3 : création de la charge#
Pour la création du chargement, on utilise les chargements évolutifs dans le temps de type evol_char produits par LIRE_RESU [U7.02.01] (ou CREA_RESU),et contenant des champs de pression, des densités de force volumique en 2D ou 3D et des densités de force surfacique en 2D ou 3D.
CHA_PROJ=AFFE_CHAR_MECA(MODELE=MODE,
EVOL_CHAR=RES_PROJ,)
Fichier de commandes#
DEBUT()
MAIL=LIRE_MAILLAGE(FORMAT='MED',);
MAIL=MODI_MAILLAGE(reuse =MAIL,
MAILLAGE=MAIL,
ORIE_PEAU_3D=_F(GROUP_MA='Group_1',),)
MAIL=DEFI_GROUP(reuse =MAIL,
MAILLAGE=MAIL,
CREA_GROUP_NO=_F(NOM='Group_3',
GROUP_MA='Group_3' ) )
MA=DEFI_MATERIAU(ELAS=_F( E = 2.E11,
NU = 0.3,
ALPHA = 1.E-5,
RHO=1. ),
ECRO_LINE=_F( D_SIGM_EPSI = 2.E9,
SY = 2.E8 ) )
MODE=AFFE_MODELE(MAILLAGE=MAIL,
AFFE=_F(TOUT='OUI',
PHENOMENE='MECANIQUE',
MODELISATION='3D',),);
MATE=AFFE_MATERIAU(MAILLAGE=MAIL,
AFFE=_F(TOUT='OUI',
MATER=MA,),);
##### création de la charge CHA_PROJ #####
# lecture du maillage (disque) porteur de l effort de pression
mail2=LIRE_MAILLAGE(UNITE=21,
FORMAT=”MED”,);
mail2=MODI_MAILLAGE(reuse =mail2,
MAILLAGE=mail2,
ORIE_PEAU_2D=_F(GROUP_MA=”disque”,),);
modele2=AFFE_MODELE(MAILLAGE=mail2,
AFFE=_F(TOUT=”OUI”,
PHENOMENE=”MECANIQUE”,
MODELISATION=”3D”,),)
# création du champ de pression sur le disque
VAL =CREA_CHAMP(TYPE_CHAM=”ELEM_PRES_R”,
OPERATION=”AFFE”, MODELE=modele2, PROL_ZERO=”OUI”, AFFE=_F(GROUP_MA = “disque”, NOM_CMP = “PRES”, VALE = 100000000. ), INFO=1,)
RES_PRES=CREA_RESU(OPERATION = “AFFE”,
TYPE_RESU = “EVOL_CHAR”,
NOM_CHAM = “PRES”,
AFFE = _F(CHAM_GD = VAL ,
MODELE = modele2,
INST = 0. ), )
# calcul de la force de pression résultante sur le disque du premier maillage
tab1=POST_ELEM(INTEGRALE = _F(GROUP_MA = “disque”,
DEJA_INTEGRE = “NON”,
NOM_CHAM = “PRES”, NOM_CMP = “PRES” ), RESULTAT = RES_PRES , MODELE = modele2 )
IMPR_TABLE(TABLE=tab1)
# projection du champ de pression depuis le disque vers la structure calculee
RES_PROJ=PROJ_CHAMP(METHODE=”COLLOCATION”,
RESULTAT=RES_PRES,
MODELE_1=modele2,
MODELE_2=MODE,
DISTANCE_MAX=1.,
CAS_FIGURE=”2.5D”,
PROL_ZERO=”OUI”,
VIS_A_VIS=_F(GROUP_MA_1=”disque”,
GROUP_MA_2=”Group_1”,),
TOUT_ORDRE=”OUI”,);
# calcul de la force de pression résultante après projection
tab2=POST_ELEM(INTEGRALE = _F(GROUP_MA = “Group_1”,
NOM_CHAM = “PRES”,
DEJA_INTEGRE = “NON”,
NOM_CMP = “PRES” ), RESULTAT = RES_PROJ , MODELE = MODE )
IMPR_TABLE(TABLE=tab2)
# création de la charge
CHA_PROJ=AFFE_CHAR_MECA(MODELE=MODE,
EVOL_CHAR=RES_PROJ,)
##### fin de creation de la charge CHA_PROJ #####
BLOQ=AFFE_CHAR_MECA(MODELE=MODE,
DDL_IMPO=_F(GROUP_MA=”Group_3”,
DX=0.0,
DY=0.0,
DZ=0.0,),)
RESU=MECA_STATIQUE(MODELE = MODE,
CHAM_MATER = MATE, EXCIT=(_F(CHARGE=BLOQ,), _F(CHARGE=CHA_PROJ,),) )
RESU=CALC_CHAMP(reuse =RESU,
FORCE=”REAC_NODA”,
RESULTAT=RESU,)
STANLEY()
FIN()
Comment calculer l’intégrale des contraintes ou d’une quantité dérivée sur le bord d’une structure 3D#
Objectif#
L’utilisateur dispose d’un champ de contraintes (aux points de Gauss). Il souhaite faire l’intégrale de chaque composante sur le bord de son modèle ou calculer une quantité dérivée comme un moment axial.
\({\int}_{S}{\sigma}_{xx}\mathit{ds}\) \({\int}_{S}{\sigma}_{xx}.y\mathit{ds}\) |
Le calcul de l’intégrale est fait par la commande POST_ELEM. Lorsque l’on souhaite intégrer une quantité dérivée d’un champ, celle-ci doit être définie (FORMULE) et évaluée (CREA_CHAMP) préalablement.
Les contraintes aux points de Gauss ne sont pas calculées directement sur les faces, aussi l’utilisateur se voit confronté à quelques difficultés. Une recette a été établie pour pouvoir réaliser ce calcul. Elle est présentée ci-dessous.
Pour plus de détails, on consultera le cas-test tplv07a qui met en œuvre cette recette dans un cadre thermique afin de calculer le flux sortant sur un bord.
Recette#
Étape 1 : calcul du champ de contraintes 3D aux nœuds#
Tout d’abord, il faut calculer les champs de contraintes aux nœuds.
CALC_CHAMP(CONTRAINTE='SIGM_NOEU',RESULTAT=...,)
L’étape suivante consiste à construire un champ neutre dont les valeurs:
sont localisées aux points de Gauss des mailles (2D et 3D), et
correspondent aux valeurs des contraintes.
Étape 2 : calcul d’un champ neutre correspondant aux contraintes#
On suppose que le modèle 3D (MO3D) qui a servi à faire le calcul contient en plus des éléments «3D», des éléments de bord (facettes) sur tous ses bords.
Cas de l’intégration d’un champ existant#
Extraction du champ de contraintes aux nœuds:
SIGNO=CREA_CHAMP(OPERATION='EXTR', TYPE_CHAM='NOEU_SIEF_R',
NOM_CHAM='SIEF_NOEU',RESULTAT=...,INST=...)
Transformation du champ SIGNO en champ neutre:
NEUTNO=CREA_CHAMP(OPERATION='ASSE', TYPE_CHAM='NOEU_NEUT_R',MODELE=MO3D,
PROL_ZERO='OUI',ASSE=_F(TOUT='OUI',CHAM_GD=SIGNO,
NOM_CMP=('SIXX','SIYY','SIZZ'),
NOM_CMP_RESU=('X1','X2','X3'),)
Cas de l’intégration d’un champ dérivé (par exemple pour le calcul d’un moment axial ou d’un flux thermique)#
Lorsque la quantité à intégrer n’existe pas directement, il faut la construire. La démarche est alors exactement la même que celle décrite au § 2.2.1 . On commencera par définir l’intégrande avec l’opérateur FORMULE, puis un champ de fonctions de type NEUT (CREA_CHAMP/OPERATION=”ASSE”) et enfin on l’évaluera (CREA_CHAMP/OPERATION=”EVAL”).
On se reportera également au cas-test tplv07a pour un exemple en thermique.
Étape 3 : calcul de l’intégrale sur le bord#
Il suffit d’intégrer le champ NEUTNO aux mailles de bord. Par exemple, pour la face “HAUT”, la commande est la suivante:
INT=POST_ELEM(CHAM_GD=NEUTNO, MODELE=MOD3D,
INTEGRALE=_F(GROUP_MA='HAUT',
NOM_CMP=('X1','X2','X3'),),)
Commandes utilisées#
Commandes |
Fonctionnalité |
CALC_CHAMP |
Création des champs de contraintes aux nœuds par éléments aux différents instants. |
CALC_CHAMP |
Création des champs de contraintes aux nœuds aux différents instants. |
AFFE_MODELE |
Création d’un modèle 3D. |
CREA_CHAMP/EXTR |
Extraction du champ de contraintes aux nœuds à l’instant INST. |
(FORMULE) |
Définition de l’intégrande le cas échéant. |
CREA_CHAMP/ASSE (CREA_CHAMP/AFFE) |
Transformation du champ de contraintes en champ neutre. Création d’un champ neutre de fonctions. |
(CREA_CHAMP/EVAL) |
Évaluation du champ de fonctions le cas échéant. |
POST_ELEM |
Calcul de l’intégrale en spécifiant les groupes de mailles de face. |
Comment relire un champ constant par éléments et le projeter aux nœuds du maillage#
Objectif#
L’utilisateur dispose d’un champ à 3 composantes constant par éléments au format MED. Il souhaite pouvoir le projeter sur les nœuds d’un autre maillage.
Plus précisément, on considère 2 maillages. Le premier est un maillage constitué de mailles surfaciques sur lequel a été calculé un champ constant par maille (issue par exemple d’un calcul fluide). Le deuxième est un maillage linéique (représentant par exemple une ligne de tuyauterie sur laquelle on souhaite projeter le champ calculé sur le premier maillage). L’enjeu est donc de relire le champ sur le maillage 1 et de le transférer aux nœuds du maillage 2.
Pour que la technique présentée ici fonctionne, il suffit simplement que les maillages soient parallèles l’un à l’autre (par exemple, il faut qu’ils soient tous les deux suivant l’axe z) et qu’ils aient une plage de coordonnées en commun suivant l’axe suivant lequel ils sont parallèles.
Méthode#
Relecture du fichier MED#
La relecture se fait en deux étapes :
Relecture du maillage 1 :
MAIL1 = LIRE_MAILLAGE(FORMAT = “MED”,);
Relecture du champs avec LIRE_CHAMP. En effet, c’est LIRE_CHAMP qui permet le plus simplement de relire des champs constants par éléments via la production du carte (au sens de Code_Aster ). Le champ a relire s’appelle ici “ForceLineique”, on le stocke dans une carte à 3 composantes de type indicateur d’erreur (ce dernier élément est anecdotique car on ne s’en sert que de conteneur) :
CH1=LIRE_CHAMP(FORMAT = “MED”,
MAILLAGE = MAIL1,
UNITE = 20,
NOM_MED = “ForceLineique”,
INST = 0.0001,
TYPE_CHAM = “CART_ERRE_R”,
NOM_CMP = (“ERREST”,”NUEST”,”SIGCAL”,),
NOM_CMP_MED = (“FX”,”FY”,”FZ”,),);
Création du résultat et projection du champ#
Pour être en mesure de projeter le champ à l’aide de PROJ_CHAMP, il faut d’abord le ranger dans une structure de donnée résultat en utilisant la commande CREA_RESU :
Création du résultat :
EVOL1=CREA_RESU(OPERATION = “AFFE”,
TYPE_RESU = “EVOL_NOLI”,
NOM_CHAM = “ERME_ELEM”,
AFFE = (_F(CHAM_GD = CH1,
INST = 0.0001,),),);
Projection :
EVOL2=PROJ_CHAMP(RESULTAT = EVOL1,
NOM_CHAM = “ERME_ELEM”,
MODELE_1 = MO1,
MODELE_2 = MO2,
TYPE_CHAM = “NOEU”,);
où MO1 et MO2 sont des modèles reposant respectivement sur le maillage 1 et le maillage 2 (dont la relecture n’est pas explicitée ici). Ces modèles doivent être cohérents entre eux et évidemment vis-à-vis de l’utilisation qu’on souhaite faire du champ plus tard. De ce fait, leur création ne fait pas partie de cette explication car elle dépend de l’application recherchée.
Au final, on obtient maintenant une nouvelle structure de donnée résultat contenant un champ aux nœuds définit sur le maillage 2. Une dernière étape (facultative) consiste à modifier le nom et le type du champ afin d’obtenir un vrai champ aux nœuds. Dans la suite, c’est ce qu’on va chercher à obtenir en convertissant le champ d’erreur obtenu en champ de déplacement (champ aux nœuds à 3 composantes).
Modification du type du champ#
La dernière étape se décompose en deux sous-étapes :
Extraction du champ :
CHTMP1 = CREA_CHAMP(OPERATION = “EXTR”,
NOM_CHAM = “ERME_ELEM”,
TYPE_CHAM = “NOEU_ERRE_R”,
RESULTAT = EVOL2,
INST = 0.0001,);
Conversion du champ :
CHNOFIN = CREA_CHAMP(OPERATION = “ASSE”,
TYPE_CHAM = “NOEU_DEPL_R”,
MODELE = MO2,
ASSE = (_F(CHAM_GD = CHTMP1,
COEF_R = 1.0,
TOUT = “OUI”,
NOM_CMP = (“ERREST”,
“NUEST”,
“SIGCAL”),
NOM_CMP_RESU = (“DX”,
“DY”,
“DZ”),),),);
Comment utiliser la valeur des fréquences propres calculées pour évaluer l’amortissement#
On souhaite interpoler une fonction d’amortissement \(F(\mathit{FREQ})=\text{f\_amor}\) sur les fréquences propres d’un modèle.
Les fréquences et modes propres sont obtenues par CALC_MODES.
modes = CALC_MODES(…)
On extrait uniquement la liste des fréquences calculées en faisant (on obtient une table composée d’une colonne avec les numéros d’ordre et une colonne avec les fréquences):
tab = RECU_TABLE(RESU=modes,
NOM_PARA=”FREQ”)
L’astuce consiste à créer une fonction identité sur la liste des fréquences \(G(\mathit{FREQ})=\mathit{FREQ}\) en récupérant les valeurs dans la table:
g_freq = RECU_FONCTION(TABLE=tab,
PARA_X=”FREQ”,
PARA_Y=”FREQ”)
L’amortissement évalué sur les fréquences propres est donc f_amor = F(G(FREQ)), soit:
amor = CALC_FONCTION(COMPOSE=_F(FONC_PARA=g_freq,
FONC_RESU=f_amor))
Cet exemple est disponible dans sdld22a.com1.
Comment définir un état de contraintes initiales (ou de variables internes) avec des formules analytiques#
Objectif#
L’objectif est de pouvoir fabriquer deux des champs constituant l’état initial d’un calcul non-linéaire: le champ de contraintes et le champ de variables internes.
Dans les deux cas, la solution consiste à enchaîner un certain nombre de commandes CREA_CHAMP.
Le lecteur est invité à consulter la documentation [U2.01.09] («Définition analytique d’un champ de contraintes et d’un champ de variables internes initiaux») qui répond explicitement à cette problématique. Il peut regarder également le fichier de commande du cas-test zzzz130a qui illustre cette mise en œuvre.
Nous présentons ci-dessous une recette «succincte» pour chacun des cas.
Fabrication d’un champ de contraintes analytique#
Recette#
Définir les formules: à partir de l’expression analytique de chaque contrainte, on construit le concept Aster correspondant à partir de l’opérateur FORMULE.
Exemple :
(la formule ainsi définie dépend de la variable Z (coordonnée géométrique)).
Création du champ de formules: on construit un champ neutre (sans grandeur particulière) pour associer à chaque formule précédemment définie, une composante de ce champ.
Création du champ de paramètres:
Nous devons disposer d’un champ dont les composantes font parties des variables des formules du champ d’évaluation. Dans cet exemple, nous devons disposer du champ géométrique (composante Z) aux points de Gauss. On procède en deux étapes :
transformation du champ aux nœuds en un champ géométrique aux points de Gauss:
Création du champ par évaluation des fonctions:
A présent, on peut évaluer le champ : on utilise l’opération EVAL :
Création du champ de contraintes: pour obtenir notre champ de contraintes analytique, il faut attribuer la grandeur SIEF_R au champ d’évaluation.
Commandes utilisées#
Commandes
Fonctionnalité
FORMULE
Création des formules
CREA_CHAMP/OPERATION=”AFFE”
Création du champ de formules
CREA_CHAMP/OPERATION=”EXTR”
Création du champ de paramètres
CREA_CHAMP/OPERATION=”EVAL”
Création du champ d’évaluation
CREA_CHAMP/OPERATION=”DISC”
Création du champ de contraintes désiré après changement de grandeur
Tableau 2.1
Fabrication d’un champ de variables internes non nul#
Deux méthodes sont envisageables pour créer un champ de variables internes non nul.
Première méthode#
Recette#
Cette méthode nécessite la connaissance du nombre de variables internes de chaque loi de comportement de votre STAT_NON_LINE. La doc U4.51.11 permet d’obtenir cette information. Cette méthode repose sur l’affectation de toutes les variables internes des lois fournies à votre STAT_NON_LINE. On utilise l’opérateur d’affectation AFFE de CREA_CHAMP pour cet effet.
Cette opération s’effectue en deux étapes:
on crée d’abord une CARTE de NEUT_R
Exemple:
VAIN = CREA_CHAMP(OPERATION='AFFE',,TYPE_CHAM='CART_NEUT_R', AFFE=(_F(GROUP_MA ='GM1', NOM_CMP=('X1','X2'),VALE=(0,,2,)), _F(GROUP_MA ='GM2', NOM_CMP=('X1','X2','X3',X4','X5'), VALE=(0,0,0,9,2,1)),...)on transforme la carte de NEUT_R en champ aux point de Gauss de VARI_R via l’opération “ASSE”:
VARI=CREA_CHAMP(OPERATION='ASSE', TYPE_CHAM='ELGA_VARI_R', ASSE=(_F(CHAM_GD=VAIN, GROUP_MA='GM1',NOM_CMP=('X1','X2'), NOM_CMP_RESU=('V1','V2')) _F(CHAM_GD=VAIN, GROUP_MA='GM2', NOM_CMP=('X1','X2','X3','X4','X5'), NOM_CMP_RESU=('V1','V2','V3','V4','V5'),),), ...)Le champ de variables internes VARI contient 2 variables internes pour les éléments du groupe \(\mathrm{GM1}\) et 5 pour \(\mathrm{GM2}\) . Ainsi la loi de comportement à appliquer sur le groupe \(\mathrm{GM1}\) du modèle dans l’opérateur de résolution devra comporter exactement 2 variables internes.
Commandes utilisées#
Commandes
Fonctionnalité
CREA_CHAMP/AFFE
Création d’une carte où toutes les composantes sont affectées.
CREA_CHAMP/OPERATION=”ASSE”
Transformation de la carte en champ de variables internes.
Deuxième méthode#
Recette#
Cette méthode permet de n’affecter explicitement que les mailles qui possèdent des composantes non nulles. On procède de la façon suivante:
On réalise un premier calcul bidon (pour bénéficier a postériori d’un champ de variables internes «modèle»):
On extrait le champ de variables internes VBID du résultat UBID:
On affecte cette fois les valeurs non-nulles:
VAIN1 = CREA_CHAMP(OPERATION='AFFE',,TYPE_CHAM='CART_NEUT_R', AFFE=(_F(GROUP_MA='GM1', NOM_CMP=('X2'),VALE=(2,)), _F(GROUP_MA ='GM2', NOM_CMP=('X3',X4','X5'),VALE=(9,2,1)),), ...)On met à zéro le champ de variables internes «modèle» et on le surcharge des valeurs non nulles:
VAIN2 = CREA_CHAMP(OPERATION='ASSE',TYPE_CHAM='ELGA_VARI_R' ASSE=(_F(TOUT='OUI',CHAM_GD=VBID, CUMUL='OUI',COEF_R=0.), _F(GROUP_MA='GM1',CHAM_GD=VAIN1, CUMUL='OUI',COEF_R=1., NOM_CMP=('X2'),NOM_CMP_RESU=('V2'),), _F(GROUP_MA='GM2',CHAM_GD=VAIN1, CUMUL='OUI',COEF_R=1., NOM_CMP=('X3','X4','X5'), NOM_CMP_RESU=('V3','V4','V5'),),),...)Commandes utilisées#
Commandes
Fonctionnalité
STAT_NON_LINE
Création d’un résultat bidon
CREA_CHAMP/EXTR
Extraction du champ de variables internes.
CREA_CHAMP/AFFE
Création d’une carte où seules les composantes non-nulles sont affectées.
CREA_CHAMP/ASSE
Transformation de la carte en champ de variables internes afin de l’assembler avec le champ extrait du résultat (préalablement remis à zéro).