6.4. [U4.22.01] : Operator DEFI_GROUP (DEFINE_GROUP)

6.4.1. Purpose

To define new groups of nodes or elements in an existing mesh. This can facilitate the definition of new geometric locations for data inputs or post-processing.

To create new groups, topological, logical or geometric criteria are used.

Modifies a data structure of type maillage (mesh), squelette (skeleton) or grille (grid).

6.4.2. Syntax

mesh [maillage] = DEFI_GROUP
(

  ◊ reuse = / mesh,
            / grid,
  ♦ | MAILLAGE = mesh,                                          / [maillage]
                                                                / [squelette]
    | GRILLE = grid,                                            / [grille]
  ♦ | DETR_GROUP_MA = _F(
                         ♦ NOM = lgma,                            [l_group_ma]
                        )
    | DETR_GROUP_NO = _F(
                         ♦ NOM =lgno,                             [l_group_no]
                        )
    | CREA_GROUP_MA = (_F(
                          ♦ NOM = gma,                            [identifier]
                           ◊ TYPE_MAILLE = / 'TOUT'               [DEFAULT]
                                           / '3D' / '2D' / '1D'
                                           / 'SEG2' / 'TRIA3'
                                           / 'QUAD4'/ 'QUAD8'
                                           / .../ 'PYRAM13'

                          ♦ / TOUT = 'OUI',

                            / INTERSEC = lgma,                    [l_group_ma]
                            / UNION = lgma,                       [l_group_ma]
                            / DIFFE = lgma,                       [l_group_ma]

                            / GROUP_MA = gma,                     [group_ma]
                              / NUME_INIT = / nuini,              [I]
                                            / 1,                  [DEFAULT]
                                NUME_FIN = nufin,                 [I]
                              / POSITION = / 'INIT',
                                           / 'FIN',
                                           / 'MILIEU',

                            / OPTION = 'FACE_NORMALE',
                              ♦ / ANGL_NAUT = (a, b),             [l_R]
                                / VECT_NORMALE = (x, y, z),       [l_R]
                              ◊ ANGL_PREC = / a,                  [R]
                                            / 0.5,                [DEFAULT]
                              ◊ VERI_SIGNE = / 'NON',
                                             / 'OUI' ,            [DEFAULT]

                            / OPTION ='SPHERE',
                              ♦ / POINT = (x, y, z),              [l_R]
                                / GROUP_NO_CENTRE = grno,         [group_no]
                              ♦ RADIUS = r,                       [R]

                            / OPTION ='CYLINDRE',
                              ♦ / POINT = (x, y, z),              [l_R]
                                / GROUP_NO_CENTRE = grno,         [group_no]
                              ♦ RAYON = r,                        [R]
                              ♦ / ANGL_NAUT = (a, b),             [l_R]
                                / VECT_NORMALE = (x, y, z),       [l_R]

                            / OPTION ='BANDE',
                              ♦ / POINT = (x, y, z),              [l_R]
                                / GROUP_NO_CENTRE = grno,         [group_no]
                              ♦ / ANGL_NAUT = (a, b),             [l_R]
                                / VECT_NORMALE = (x, y, z),       [l_R]
                              ♦ DIST = d,                         [R]

                            / OPTION ='APPUI',
                              ♦ GROUP_NO = lgno,                  [l_group_no]
                              ♦ TYPE_APPUI = / 'AU_MOINS_UN'
                                             / 'TOUT'
                                             / 'SOMMET'
                                             / 'MAJORITE'

                            / OPTION ='FISS_XFEM',
                              ♦ FISSURE = (fiss1, fiss2, ...),    [l_fiss_xfem]
                              ♦ TYPE_GROUP = / 'XFEM'
                                             / 'HEAVISIDE'
                                             / 'CRACKTIP'
                                             / 'MIXTE'
                                             / 'FISSUREE'
                         )),

    | CREA_GROUP_NO = (_F(
                          / ♦ NOM = gno,                          [identifier]
                            ♦ / INTERSEC = lgno,                  [l_group_no]
                              / UNION = lgno,                     [l_group_no]
                              / DIFFE = lgno,                     [l_group_no]

                              / GROUP_NO = gno,                   [group_no]
                                / NUME_INIT = / nuini,            [I]
                                              / 1,                [DEFAULT]
                                  NUME_FIN = nufin,               [I]
                                / POSITION = / 'INIT',
                                             / 'FIN',
                                             / 'MILIEU' ,

                              / OPTION = 'ENV_SPHERE',
                                ♦ / POINT = (x, y, z),            [l_R]
                                  / GROUP_NO_CENTRE = grno,       [group_no]
                                ♦ RAYON = r,                      [R]
                                ♦ PRECISION = eps,                [R]

                             / OPTION = 'ENV_CYLINDRE',
                               ♦ / POINT = (x, y, z),             [l_R]
                                 / GROUP_NO_CENTRE = grno,        [group_no]
                               ♦ RAYON = r,                       [R]
                               ♦ / ANGL_NAUT = (a, b),            [l_R]
                                 / VECT_NORMALE = (x, y, z),      [l_R]
                               ♦ PRECISION = eps,                 [R]

                             / OPTION = 'PLAN',
                               ♦ / POINT = (x, y, z),             [l_R]
                                 / GROUP_NO_CENTRE = grno,        [group_no]
                               ♦ / ANGL_NAUT = (a, b),            [l_R]
                                 / VECT_NORMALE = (x, y, z),      [l_R]
                               ♦ PRECISION = eps,                 [R]

                             / OPTION = 'SEGM_DROI_ORDO',
                               ♦ GROUP_NO = gno2,                 [group_no]
                               ♦ GROUP_NO_ORIG = gnoA,            [group_no]
                               ♦ GROUP_NO_EXTR = gnoB,            [group_no]
                               ♦ PRECISION = prec,                [R]
                               ♦ CRITERE = / 'RELATIF',
                                           / 'ABSOLU' ,

                             / OPTION = 'NOEUD_ORDO',
                               ♦ GROUP_MA = gmaAB,                [group_ma]
                               ◊ GROUP_NO_ORIG = gnoA,            [group_no]
                               ◊ GROUP_NO_EXTR = gnoB,            [group_no]
                               ◊ VECT_ORIE = (vx, vy, [vz]),      [l_R]

                             / OPTION = 'TUNNEL',
                               ♦ / TOUT = 'OUI'
                                 / GROUP_MA = lgma,               [l_group_ma]
                               ♦ GROUP_MA_AXE = gnoA,             [l_group_ma]
                               ♦ GROUP_NO_ORIG = gnoA,            [group_no]
                               ♦ RAYON = r,                       [R]
                               ◊ LONGUEUR = long,                 [R]

                             / OPTION = 'INCLUSION',
                               ♦ GROUP_MA = lgma,                 [l_group_ma]
                               ♦ CAS_FIGURE = / '2D'
                                              / '3D'
                                              / '2.5D'
                               ◊ DISTANCE_MAX = distma            [R]
                               ♦ GROUP_MA_INCL = lgma_inc,        [l_group_ma]
                               ◊ MAILLAGE_INCL = ma_inc,          [maillage]

                             / OPTION = 'INTERVALLE_VALE',
                               ♦ CHAM_GD = chno,                  [cham_no]
                               ♦ NOM_CMP = cmp,                   [TXM]
                               ♦ VALE= (vmin, vmax)               [R]

                             / OPTION = 'FISS_XFEM',
                               ♦ FISSURE = (fiss1, fiss2, ...),   [l_fiss_xfem]
                               ♦ TYPE_GROUP = / 'XFEM'
                                              / 'HEAVISIDE'
                                              / 'CRACKTIP'
                                              / 'MIXTE'
                                              / 'ZONE_MAJ'
                                              / 'TORE'

                               # If TYPE_GROUP = 'TORE':
                                 ♦ RAYON_TORE = r,                [R]

                             / OPTION = 'RELA_CINE_BP',
                               ♦ CABLE_BP = cable_bp,             [cable_precont]
                               ♦ PREF_GRNO = pref,                [TXM]
                                           = 'RCBP'               [DEFAULT]

                             / GROUP_MA = lgma,                   [identifier]
                               ◊ NOM = lgno,                      [l_group_no]
                               ◊ CRIT_NOEUD = / 'TOUT',           [DEFAULT]
                                              / 'SOMMET',
                                              / 'MILIEU',
                                              / 'CENTRE',

                             / TOUT_GROUP_MA = 'OUI',
                         )),

  ◊ ALARME = / 'OUI',                                             [DEFAULT]
             / 'NON',

  ◊ INFO = / 1,                                                   [DEFAULT]
           / 2,
)

Result type:

  • If MAILLAGE : maillage then maillage

  • If MAILLAGE : squelette then squelette

  • If GRILLE : grille then grille

6.4.3. Operands

6.4.3.1. General information on operands

This command treats concepts of type maillage (mesh) or squelette (skeleton) in the same way. In the following we will use the term “mesh” to stand for either.

This command makes it possible to define new element groups (or groups of nodes) in an existing mesh: one enriches the mesh mesh.

The definition of a new group can be done in several ways:

  • by Boolean operations on existing groups: intersection (INTERSEC), union (UNION) or difference (DIFFE),

  • according to a geometrical criterion: elements of which a node belongs to a given sphere, …

  • for the nodes groups, by referring to existing element groups. The node group thus defined contains all the nodes of the elements of the original element group (keywords TOUT_GROUP_MA and GROUP_MA).

The operator first treats the keyword CREA_GROUP_MA so that one can make use of the groups of elements thus defined in the keyword CREA_GROUP_NO.

With each occurrence of a keyword CREA_GROUP_MA (_NO) a new named group is defined (keyword NOM). This new group can then be reused in the subsequent occurrences to define new groups by intersection, union, etc.

Keywords DETR_GROUP_MA and DETR_GROUP_NO allow the user “to destroy” element or node groups. The elements and the nodes of these groups are not removed, only the group definitions are deleted. These keywords are useful in Python loops when we want to create a group at each iteration of the loop: we start by destroying this group then we recreate it under the same name. This avoids changing the group name at each iteration.

It can be noted that most of the features of DEFI_GROUP are feasible directly in the SALOME SMESH module, namely:

  • boolean operation on existing groups,

  • group creation by type of element (SMESH Type filter),

  • according to a geometric criterion (SMESH LyingOn filter),

  • according to a criterion of angle of normal for surface meshes (SMESH Coplanar filter),

  • for the element groups leaning on nodes groups (SMESH 'Group based on nodes of other groups' function),

  • for the nodes groups, by referring to existing element groups (SMESH 'Group based on nodes of other groups' function),

  • deleting groups.

6.4.3.2. Operands MAILLAGE and GRILLE (MESH and GRID)

♦ | MAILLAGE = mesh

mesh is the name of the mesh which one wants to add new groups to.

| GRILLE = grid

grid is the name of the auxiliary grid that we want to “enrich”.

6.4.3.3. Keywords DETR_GROUP_MA and DETR_GROUP_NO (DESTROY_ELEMENT/NODE_GROUP)

These two keyword factors make it possible to delete element or node groups. These keywords are sometimes necessary because the code stops with a fatal error if one tries to create a group whose name is already in use. You have to destroy the group before you can use its name again. The behavior of the two keywords is similar and on DETR_GROUP_MA (DESTROY_ELEMENT_GROUP) will be discussed here.

DETR_GROUP_MA = _F(NOM = (gm1, gm2, ...)),

The keyword factor DETR_GROUP_MA is repeatable, but that is never necessary because the keyword NOM (NAME) is used to indicate a list of group names to destroy (gm1, gm2, …).

It is important to know that all the occurrences of the keyword DETR_GROUP_MA are executed before those of the keyword CREA_GROUP_NO because the objective of this keyword is to be able to reuse the destroyed name. You should also know that the destruction of a non-existent group does not cause any alarm message. These choices allow, for example, to use a Python loop for creation and destruction og groups:

for i in range(n):

    DEFI_GROUP(reuse = mesh,
               MAILLAGE = mesh,
               DETR_GROUP_MA = _F(NOM = ('GM1')),
               CREA_GROUP_MA = _F(NOM = 'GM1',
               ...

During the first iteration, the group ‘GM1’ does not exist, we ask for its destruction but no alarm message is issued.

Remark

As the destruction takes place at the start of the command, it is impossible to modify a group by making only one call to DEFI_GROUP. For example, we cannot extend a group in a loop by adding a small group (b1) to it:

for i in range(n):

  b1 = new group ...
  DEFI_GROUP(reuse = mesh,
             MAILLAGE = mesh,
             CREA_GROUP_MA = _F(NOM = 'all',
                                UNION = ('all', 'b1')))

To do this, you have to call DEFI_GROUP twice:

for i in range(n):

   b1 = new group ...
   DEFI_GROUP(reuse = mesh,
              MAILLAGE = mesh,
              DETR_GROUP_MA = _F(NOM = 'all2'),
              CREA_GROUP_MA = _F(NOM = 'all2',
                                 UNION = ('all', 'b1')))
   DEFI_GROUP(reuse = mesh,
              MAILLAGE = mesh,
              DETR_GROUP_MA = _F(NOM = 'all'),
              CREA_GROUP_MA = _F(NOM = 'all',
                                 UNION = ('all2', 'b1')))

6.4.3.4. Keyword CREA_GROUP_MA (CREATE_ELEMENT_GROUP)

| CREA_GROUP_MA

An occurrence of this keyword factor makes it possible to define a new group of elements.

6.4.3.4.1. Operand ‘NOM’ (NAME)

♦ NOM = gma

The name (with “quotes”) of the new group of elements.

6.4.3.4.2. Operand TYPE_MAILLE (ELEMENT_TYPE)

◊ TYPE_MAILLE = / 'TOUT'                     [DEFAULT]
                / '3D'
                / '2D'
                / '1D'
                / 'SEG2'
                / 'TRIA3'
                / 'QUAD4'
                / ...
                / 'PYRAM13'

This keyword makes it possible to filter the elements which one will select for the new group of elements.

By default, there is no filter, but if the user writes for example: TYPE_MAILLE = ‘2D’,the created group will contain only surface elements.

The user can also filter the group to be created for a particular type of element (TRIA3, HEXA27, etc.). All the types of elements (POI1, SEG2, SEG3, SEG4, …, PYRAM13) are allowed.

Examples:

CREA_GROUP_MA = _F(NOM = 'VOLUM',
                   TOUT = 'OUI',
                   TYPE_MAILLE = '3D')

allows us to create a group of all the volume elements (HEXA, PENTA, …) of the mesh.

CREA_GROUP_MA = _F(NOM = 'VOLH27',
                   GROUP_MA = 'GMA1',
                   TYPE_MAILLE = 'HEXA27')

allows us to create a group of all the elements of the type ‘HEXA27’ contained in the element group GMA1.

6.4.3.4.3. Operand TOUT (ALL)

/ TOUT = 'OUI'

This keyword makes it possible to define a group containing all the elements of the mesh.

6.4.3.4.4. Operand INTERSEC (BOOLEAN_INTERSECTION)

/ INTERSEC = (gma1, gma2, gma3, ...),

The new element group will be obtained by taking all the elements of gma1 which also belong to gma2, gma3, ….

The element order remains that of gma1.

6.4.3.4.5. Operand UNION (BOOLEAN_UNION)

/ UNION = (gma1, gma2, gma3, ...)

The new element group will be obtained by taking all the elements of gma1, then adding the elements of gma2 which do not belong to gma1, then those of gma3 which do not belong to gma1 or gma2, etc.

6.4.3.4.6. Operand DIFFE (BOOLEAN_DIFFERENCE)

/ DIFFE = (gma1, gma2, gma3, ...)

The new element group will be obtained by taking all the elements of gma1 which do not belong to the other groups in the list. The order of the elements remains that of gma1.

6.4.3.4.7. Sub-group of an existing group: keywords GROUP_MA/POSITION/NUME_INIT/NUME_FIN

One can create a new group of elements by selecting certain meshes of an existing group.

First possibility:

One creates a group of only one element by specifying the required element with the keyword POSITION.

Example:

CREA_GROUP_MA = _F(GROUP_MA = G1,
                   POSITION = 'INIT',
                   NOM = G1I)

The G1I group contains the first element of the G1 element group.

Second possibility:

We create a group containing the elements between the rows nuini and nufin (included) in an existing group.

Example:

CREA_GROUP_MA = _F(GROUP_MA = G1,
                   NUME_INIT = 3,
                   NUME_FIN = 7,
                   NOM = G1P)

The group G1P contains the elements 3, 4, 5, …, 7 of G1.

Warning

These key words use the notion of order of the elements in a group of elementss. This order is often unknown to the user. It may depend on the preprocessor. It is the order of the elements during the definition of the element group in the Aster mesh file.

6.4.3.4.8. Operand OPTION = ‘FACE_NORMALE’

/ OPTION = 'FACE_NORMALE'

This option makes it possible to define an element group made up of surface elements whose normal is parallel to the direction of the vector defined by its components if the keyword VECT_NORMALE is used, or that of the first vector of the new basis defined by a reference coordinate system defined via to nautical angles.

In 3D, it is assumed that the surface elements are plane faces. They are of type TRIA3, TRIA6, QUAD4, QUAD8 or QUAD9. If we call \(\mathbf{X}_1\), \(\mathbf{X}_2\), and \(\mathbf{X}_3\) the position vectors of the first three vertex nodes of the element, the normal is determined by the vector product: \((\mathbf{X}_2 - \mathbf{X}_1) \wedge (\mathbf{X}_3 - \mathbf{X}_1)\).

In 2D, it is supposed that the surface elements are straight segments. They are of type SEG2 or SEG3. If one calls \(\mathbf{X}_1\) and \(\mathbf{X}_2\) the position vectors of the two end nodes of the element, the normal is defined as \((\mathbf{X}_2 - \mathbf{X}_1) \wedge \mathbf{z}\) where \(\mathbf{z}\) is the unit vector perpendicular to the plane and which was assigned 0 as the third component in \((\mathbf{X}_2 - \mathbf{X}_1)\).

Remark

A “face” mesh will be retained if its normal is collinear with the normal vector defined by VECT_NORMALE. This condition must be satisfied with a certain precision (keyword ANGL_PREC).

When one chooses an ANGL_PREC (for example 30 degrees), one in fact defines the group of elements whose normal belongs to the cone of axis VECT_NORMALE and angle at the vertex ANGL_PREC.

This can be used (for example) to group the elements of a hemispherical envelope (ANGL_PREC = 90.).

6.4.3.4.8.1. Operand ANGL_NAUT (NAUTICAL_ANGLES)
♦ / ANGL_NAUT = a,       # in 2D
              = (a b),  # in 3D

The nautical angles a, b defined in degrees, are the angles between the global coordinate system and a coordinate system whose first vector indicates the direction of the normal of the surface elements which one wishes to select.

For the definition of the nautical angles, to see the operator AFFE_CARA_ELEM [U4.42.01] operand ORIENTATION.

6.4.3.4.8.2. Operand VECT_NORMALE (NORMAL_VECTOR)
♦ / VECT_NORMALE = (x, y),      # in 2D
                   (x, y, z),   # in 3D

x, y, and z are the components of a vector in the direction of the normal of the surface elements which one wishes to select.

6.4.3.4.8.3. Operand ANGL_PREC
◊ ANGL_PREC = prec

This is the acceptable tolerance, in degrees, on the angle formed by the vector provided by the user and the vector normal to the surface element to affirm that these two vectors have the same direction.

The default value of prec is 0.5 degrees.

6.4.3.4.8.4. Operand VERI_SIGNE
◊ VERI_SIGNE = / 'NON',
               / 'OUI',                   [DEFAULT]

If one assigns the value ‘NON’ to VERI_SIGNE, the element group will be made up of the surface elements whose normal is parallel to the vector given by the user.

If one chooses the value ‘OUI’, the element group will be made up of the surface elements whose normal is parallel and has the same orientation as the vector given by the user.

The default value is ‘OUI’.

6.4.3.4.9. Operand OPTION = ‘SPHERE’

/ OPTION = 'SPHERE'

This option makes it possible to define an element group made up of elements of which at least one node belongs to a sphere (a circle in 2D) defined by its center and its radius.

6.4.3.4.9.1. Operand POINT
♦ / POINT = (x, y)         # in 2D
            (x, y, z)      # in 3D

x, y, z are the coordinates of the center of the sphere.

6.4.3.4.9.2. Operand GROUP_NO_CENTRE (NODE_GROUP_CENTER)
♦ GROUP_NO_CENTRE = nd_grp

This keyword makes it possible to indicate the node coinciding with the center of the sphere.

6.4.3.4.9.3. Operand RAYON (RADIUS)
♦ RAYON = r

r is the radius of the sphere (of the circle in 2D).

6.4.3.4.10. Operand OPTION = ‘CYLINDRE’

/ OPTION = 'CYLINDRE'

This option makes it possible to define an element group containing elements of which at least one node belongs to a cylinder defined by its axis and radius.

The axis is defined by a vector and a point on the axis.

This option can only be used in 3D.

6.4.3.4.10.1. Operand POINT
♦ / POINT = (x, y, z)

x, y, z are the coordinates of a point on the axis of the cylinder.

6.4.3.4.10.2. Operand GROUP_NO_CENTRE (NODE_GROUP_CENTER)
♦ GROUP_NO_CENTRE = nd_grp

This keyword makes it possible to indicate a node group containing a node located on the axis of the cylinder.

6.4.3.4.10.3. Operand RAYON (RADIUS)
♦ RAYON = r

r is the radius of the cylinder.

6.4.3.4.10.4. Operand ANGL_NAUT (NAUTICAL_ANGLES)
♦ / ANGL_NAUT = (a b),

The nautical angles a, b defined in degrees, are the angles between the global coordinate axes and the axis of the cylinder.

For the definition of the nautical angles, to see the operator AFFE_CARA_ELEM [U4.42.01] operand ORIENTATION.

6.4.3.4.10.5. Operand VECT_NORMALE (NORMAL_VECTOR)
♦ / VECT_NORMALE = (x, y, z)

x, y, z are the coordinates of a vector indicating the orientation of the axis of the cylinder.

6.4.3.4.11. Operand OPTION = ‘BANDE’ (LAYER)

/ OPTION = 'BANDE'

This option makes it possible to define an element group containing elements of which at least one node belongs to a “layer” defined by a “middle” plane (a straight line in 2D) and the half-width on both sides of this plane.

The plane is defined by a vector normal to this plane and a point belonging to it.

6.4.3.4.11.1. Operand POINT
♦ / POINT = (x, y)      # in 2D
            (x, y, z)   # in 3D

x, y, z are the coordinates of a point belonging to the “middle” plane of the layer.

6.4.3.4.11.2. Operand GROUP_NO_CENTRE (NODE_GROUP_CENTER)
♦ GROUP_NO_CENTRE = nd_grp

This keyword makes it possible to select a node group containing a node belonging to the “middle” plane of the layer.

6.4.3.4.11.3. Operand ANGL_NAUT (NAUTICAL_ANGLES)
♦ / ANGL_NAUT = a,       # in 2D
              = (a b),  # in 3D

The nautical angles a, b defined in degrees, are the angles between the global coordinate system and a coordinate system whose first vector is orthogonal to the “middle” plane of the layer.

For the definition of the nautical angles, to see the operator AFFE_CARA_ELEM [U4.42.01] operand ORIENTATION.

6.4.3.4.11.4. Operand VECT_NORMALE (NORMAL_VECTOR)
♦ / VECT_NORMALE = (x, y),      # in 2D
                   (x, y, z),   # in 3D

x, y, and z are the components of a vector perpendicular to the “middle” plane of the layer.

6.4.3.4.11.5. Operand DIST
♦ DIST = d

d is the half-width of the layer.

6.4.3.4.12. Operand OPTION = ‘APPUI’ (ELEMENT_SUPPORT)

This option makes it possible to select the element group for which certain nodes belong to the node group specified by the keyword GROUP_NO.

GROUP_NO = l_gno

This keyword makes it possible to define the list of the nodes which will be used as support for the elements.

Let us call this list lno1.

♦ TYPE_APPUI = / 'TOUT',
               / 'SOMMET',
               / 'AU_MOINS_UN',
               / 'MAJORITE'

If the type is ‘TOUT (ALL), the element will be selected if all its nodes belong to lno1.

If the type is ‘SOMMET’ (VERTEX), the element will be selected if all its vertex nodes belong to lno1.

If the type is ‘AU_MOINS_UN’ (AT_LEAST_ONE) the element will be selected if at least one of its nodes belongs to lno1.

If the type is ‘MAJORITE’ (MAJORITY), the element will be selected if more than half of its nodes belong to lno1.

6.4.3.4.13. Operand OPTION = ‘FISS_XFEM’ (CRACK_XFEM)

This option makes it possible to select the X-FEM element group specified by the keyword TYPE_GROUP.

♦ FISSURE = (fiss1, fiss2, ...)
♦ TYPE_GROUP = / 'HEAVISIDE',
               / 'CRACKTIP',
               / 'MIXTE',
               / 'XFEM',
               / 'FISSURE'

For option ‘HEAVISIDE’, the element will be selected if it is of Heaviside type.

For option ‘CRACKTIP’, the element will be selected if it is of Crack-tip type.

For option ‘MIXTE’ (MIXED), the element will be selected if it is of Mixed type (Heaviside and Crack-tip).

For option ‘XFEM’, the element will be selected if it is of type Heaviside, Crack-tip or Mixed.

For option ‘FISSURE’ (CRACK), the element will be selected if all its nodes are enriched

For a precise definition of the notions of Heaviside element and Crack-tip element, see R7.02.12, Section 15.2.4.2.5.

6.4.3.5. Keyword CREA_GROUP_NO (CREATE_NODE_GROUP)

| CREA_GROUP_NO

An occurrence of this keyword factor makes it possible to define a new group of nodes (for the keywords GROUP_MA and TOUT_GROUP_MA, one creates several groups of nodes “at once”).

6.4.3.5.1. Operand NOM (NAME)

/♦ NOM = gno

Used to indicate the name (with “quotes”) of the new group of nodes.

6.4.3.5.2. Operand INTERSEC (BOOLEAN_INTERSECTION)

/ INTERSEC = (gno1, gno2, gno3, ...)

The new group of nodes will be obtained by taking all the nodes of gno1 which also belong to gno2, gno3, ….

The order of the nodes remains that of gno1.

6.4.3.5.3. Operand UNION (BOOLEAN_UNION)

/ UNION = (gno1, gno2, gno3, ...)

The new group of nodes will be obtained by taking all the nodes of gno1, then adding the nodes of gno2 which do not belong to gno1, then those of gno3 which do not belong to gno1 or gno2, etc.

6.4.3.5.4. Operand DIFFE (BOOLEAN_DIFFERENCE)

/ DIFFE = (gno1, gno2, gno3, ...)

The new group of nodes will be obtained by taking all the nodes of gno1 which do not belong to the other groups in the list. The order of the nodes remains that of gno1.

6.4.3.5.5. Subgroup of an existing group: keywords GROUP_NO / POSITION /NUME_INIT / NUME_FIN

You can create a new node group by selecting certain nodes from an existing group.

First possibility:

One creates a group of only one node by specifying the node with the keyword POSITION.

Example :

CREA_GROUP_NO = _F(GROUP_NO = G1,
                   POSITION = 'INIT',
                   NOM = G1I)

The G1I group contains the first node of the G1 node group.

Second possibility:

One creates a group containing the nodes ranging between the rows nuini and nufin (included) in an existing group.

Example :

CREA_GROUP_NO = _F(GROUP_NO = G1,
                   NUME_INIT = 3,
                   NUME_FIN = 7,
                   NOM = G1P)

The G1P group contains nodes 3, 4, 5, …, 7 of G1.

Warning

These key words use the notion of order of the nodes in a group of nodes. This order is often unknown to the user. It may depend on the preprocessor. It is the order of the nodes during of the definition of GROUP_NO in the Aster mesh file.

6.4.3.5.6. Operand OPTION = ‘ENV_SPHERE’ (SPHERE_ENVELOPE)

/ OPTION = 'ENV_SPHERE'

This option makes it possible to define a node group made up of the nodes located on the envelope of a sphere to a given precision.

6.4.3.5.6.1. Operand POINT
♦ /POINT = (x, y),   # in 2D
           (x, y, z) # in 3D

x, y, z are the coordinates of the center of the sphere.

6.4.3.5.6.2. Operand GROUP_NO_CENTRE (NODE_GROUP_CENTER)
♦ GROUP_NO_CENTRE = nd_grp

This keyword makes it possible to define the node coinciding with the center of the sphere.

6.4.3.5.6.3. Operand RAYON (RADIUS)
♦ RADIUS = r

r is the radius of the sphere.

6.4.3.5.6.4. Operand PRECISION
◊ PRECISION = eps

eps is the tolerance used to determine whether a node is inside the sphere.

This tolerance is to be taken in the following sense:

if \(d\) is the distance of a node from the center of the sphere, we say that this node belongs to the group if : \(|d - r| \le \text{eps}\).

6.4.3.5.7. Operand OPTION = ‘ENV_CYLINDRE’ (CYLINDER_ENVELOPE)

/ OPTION = 'ENV_CYLINDRE'

This option makes it possible to define a node group made up of nodes located on the envelope of a cylinder to a given precision.

This option only makes sense in 3D.

6.4.3.5.7.1. Operand POINT
♦ / POINT = (x, y, z)

x, y, z are the coordinates of a point belonging to the axis of the cylinder.

6.4.3.5.7.2. Operand GROUP_NO_CENTRE (NODE_GROUP_CENTER)
♦ GROUP_NO_CENTRE = nd_grp

This keyword makes it possible to define a node group from nodes belonging to the axis of the cylinder.

6.4.3.5.7.3. Operand RAYON (RADIUS)
♦ RAYON = r

r is the radius of the cylinder.

6.4.3.5.7.4. Operand ANGL_NAUT (NAUTICAL_ANGLES)
♦ / ANGL_NAUT = (a b),

The nautical angles a, b defined in degrees, are the angles between the global coordinate axes and the axis of the cylinder.

For the definition of the nautical angles, to see the operator AFFE_CARA_ELEM [U4.42.01] operand ORIENTATION.

6.4.3.5.7.5. Operand VECT_NORMALE (NORMAL_VECTOR)
♦ / VECT_NORMALE = (x, y, z)

x, y, z are the coordinates of a vector indicating the orientation of the axis of the cylinder.

6.4.3.5.7.6. Operand PRECISION
◊ PRECISION = eps

eps is the tolerance with which one defines the membership of a node in the envelope of the cylinder.

This tolerance is to be taken in the following sense:

if \(d\) denotes the distance from the current point to the axis of the cylinder, we say that the current point belongs to the cylinder casing if: \(| d - r | \le \text{eps}\).

6.4.3.5.8. Operand OPTION = ‘PLAN’ (PLANE)

This option makes it possible to define a node group made up of nodes located on a line (in 2D) or on a plane (in 3D) to a given precision.

6.4.3.5.8.1. Operand POINT
♦ / POINT = (x, y),    # in 2D
          = (x, y, z), # in 3D

x, y, z are the coordinates of a point belonging to the plane.

6.4.3.5.8.2. Operand GROUP_NO_CENTRE (NODE_GROUP_CENTER)
♦ GROUP_NO_CENTRE = nd_grp

This keyword makes it possible to define a node belonging to the plane.

6.4.3.5.8.3. Operand ANGL_NAUT (NAUTICAL_ANGLES)
♦ / ANGL_NAUT = a,       # in 2D
              = (a b),  # in 3D

The nautical angles a, b defined in degrees, are the angles relating the global reference used for the definition of the nodal coordinates to a reference coordinate system whose first vector is orthogonal to the ‘middle’ plane of the layer.

For the definition of the nautical angles, to see the operator AFFE_CARA_ELEM [U4.42.01] operand ORIENTATION.

6.4.3.5.8.4. Operand VECT_NORMALE (NORMAL_VECTOR)
♦ / VECT_NORMALE = (x, y),      # in 2D
                   (x, y, z),   # in 3D

x, y, and z are the components of a vector perpendicular to the plane (right-hand rule).

6.4.3.5.8.5. Operand PRECISION
◊ PRECISION = eps

eps is the tolerance with which one defines the membership of a node on a plane (or on a straight line).

This tolerance is to be taken in the following sense:

if \(d\) is the distance from the node to the plane (or to the straight line), we say that this node belongs to this plane (or to this line) if: \(|d| \le \text{eps}\).

6.4.3.5.9. Operand OPTION = ‘SEGM_DROI_ORDO’ (ORDERED_NODES_NEAR_STRAIGHT_SEG)

This option is used to order a set of nodes approximately located on a straight segment AB.

♦ GROUP_NO = nd_grp_2,

Used to define the set of nodes that we want to order.

♦ GROUP_NO_ORIG = nd_grp_A,
♦ GROUP_NO_EXTR = nd_grp_B

Used to define nodes A and B, the origin and the end of segment AB .

♦ PRECISION = prec,
♦ CRITERE = / 'RELATIF',
            / 'ABSOLU' ,

These two arguments are safeguards, they are used to check that the nodes that we seeks to order are indeed on the segment AB. If the distance of a node from AB is greater than prec the code stops with a fatal error.

If the chosen criterion is ‘RELATIF’, the distance of a node from AB will be divided by the length of AB while checking the criterion.

6.4.3.5.10. Operand OPTION = ‘NOEUD_ORDO’ (ORDERED_NODES)

This option is used to create an ordered node group containing the nodes of a set of elements composed of segments (SEG2, SEG3 or SEG4). The ensemble of these elements must form a continuous line. The line can be “open” (with 2 ends) or “closed” (it is then a simple loop).

♦ GROUP_MA = el_grp_AB

Name of element group based on which the nodes will be ordered. The elements of el_grp_AB must form an open continuous line.

◊ GROUP_NO_ORIG = nd_grp_A,
◊ GROUP_NO_EXTR = nd_grp_B

These keywords are used to define nodes A and B, the origin and the end of the line AB.

Node A will be numbered first, then the topology of the elements of el_grp_AB is used to number the nodes in sequence.

If node A is not provided by the user, the program will choose the first node of el_grp_AB that belongs to only one element as the start node. The origin is therefore arbitrary: the program might as well have chosen the other end.

If the end node is provided, the program checks that the last numbered node is indeed B.

6.4.3.5.10.1. Case of closed loops

If the line is a loop, we cannot automatically determine its ends. To define the origin of the curvilinear coordinates along the arc length, the user can input the origin and end node. It is necessary that these 2 nodes are identical. But the user can also write: ORIGINE = ‘SANS’ (ORIGIN = ‘NONE’). The “origin” node will then be taken at random on the closed loop.

To orient a closed line, one cannot make use of the knowledge of the origin and end nodes. If one wishes it, the user can then input the keyword VECT_ORIE (ORIENTATION_VECTOR) (2 or 3 coordinates depending on the size of the space). We will choose as direction of travel of the loop, the element of el_grp_AB which touches the origin nodes and which minimizes the angle with the vector provided by VECT_ORIE.

6.4.3.5.11. Operand OPTION = ‘TUNNEL’

This option is used to create the node group from nodes located inside a “tunnel” for which one provides the axis and radius. The nodes selected will be those whose distance to the axis is less than the radius.

The axis of the “tunnel” is defined by the linear elements provided via the keyword GROUP_MA_AXE.

The axis of the tunnel must have an “origin” defined by the keyword GROUP_NO_ORIG.

The keyword RAYON (RADIUS) is used to define the “radius” of the tunnel.

One can limit the tunnel by giving its length by the key word LONGUEUR (LENGTH). This length is measured from the origin of the tunnel.

The candidate nodes to be part of the tunnel are those carried by the elements defined by the keywords: TOUT = ‘OUI’ (ALL = ‘YES’) and GROUP_MA (ELEM_GROUP).

6.4.3.5.12. Operand OPTION = ‘INCLUSION’

/ OPTION = 'INCLUSION',
  ♦ GROUP_MA = l_el_grp,                           [l_group_ma]
  ♦ CAS_FIGURE = / '2D'
                 / '3D'
                 / '2.5D'
  ◊ DISTANCE_MAX = max_dist,
  ♦ GROUP_MA_INCL = l_el_grp_inc,                  [l_group_ma]
  ◊ MAILLAGE_INCL = mesh_inc,                      [maillage]

This option makes it possible to create the group of the nodes from the elements of l_el_grp which are geometrically inside the elements of l_el_grp_inc.

If MAILLAGE_INCL is not provided, l_el_grp_inc is a list of element groups of the mesh which one enriches.

If not they are elements of mesh_inc.

The keyword CAS_FIGURE is compulsory. It is used to determine which are the elements of l_el_grp_inc which should be used to determine inclusion:

  • if CAS_FIGURE = ‘2D’, one is only interested in surface elements (TRIA and QUAD) of a 2D mesh (XOY plane).

  • if CAS_FIGURE = ‘3D’, one is only interested in volume elements (TETRA, PENTA,…)’

  • if CAS_FIGURE = ‘2.5D’, one is only interested in surface elements (TRIA and QUAD) of a 3D mesh (shell).

The DISTANCE_MAX keyword is optional. It is used to give a small tolerance to define if a node is included in an element. Indeed, a node located “right” on an interface between 2 elements, risks being considered as “outside” the 2 elements and therefore as not forming part of the inclusion. This is why a default value of max_dist is used by the code. We chose 1% of the length of the smallest edge of the mesh mesh_inc.

In the case of a mesh of the type “shell” (2.5D), if the surface is not plane, it is almost impossible that a face element geometrically included in other elements: there is almost always a deviation in the direction “normal” to the surface. In general, therefore, in this case, provide a value of max_dist greater than the default.

6.4.3.5.13. Operand OPTION = ‘INTERVALLE_VALE’ (INTERVAL_VALUE)

This option is used to create the group_no from nodes at which the value of a component (cmp) of a field (cham_no) is included between two values (vmin and vmax).

The field and the component which will be used to select the nodes are given by the keywords CHAM_GD (FIELD) and NOM_CMP (COMPONENT_NAME).

The values vmin and vmax are supplied via the keyword VALE.

Example :

DEFI_GROUP(reuse = mesh,
           MAILLAGE = mesh,
           CREA_GROUP_NO = _F(NOM = 'nd_grp_1',
                              OPTION = 'INTERVALLE_VALE',
                              CHAM_GD = temper,
                              NOM_CMP = 'TEMP',
                              VALE = (700., 800.)))

The node group ‘nd_grp_1’ will be formed from all the nodes of the mesh whose temperature in the temper field is between 700 and 800.

6.4.3.5.14. Operand OPTION = ‘FISS_XFEM’ (XFEM_CRACK)

This option makes it possible to retrieve the group of XFEM type nodes specified by the keywords TYPE_GROUP.

♦ FISSURE = (crack1, crack2, ...)
♦ TYPE_GROUP = / 'XFEM'
               / 'HEAVISIDE'
               / 'CRACKTIP'
               / 'MIXTE'
               / 'ZONE_MAJ'
               / 'TORE'

If TYPE_GROUP = ‘XFEM’, the node will be retained if it is an enriched node.

If TYPE_GROUP = ‘HEAVISIDE’, the node will be retained if it is an enriched node of the Heaviside type.

If TYPE_GROUP = ‘CRACKTIP’, the node will be retained if it is an enriched node of Cracktip type

If TYPE_GROUP = ‘MIXTE’, the node will be retained if it is an enriched node of Mixed type (Heaviside and Cracktip).

If TYPE_GROUP = ‘ZONE_MAJ’, the node will be retained if it is contained in the zone of update of the level sets. If the crack mesh is input via the keyword MAILLAGE (:gray:`MESH) (Section 6.4.3.2), the update zone includes:

  • in the absence of an auxiliary mesh associated with the crack, with the computation field around the background mesh,

  • in the presence of an auxiliary mesh associated with the crack, with the projection field between background mesh and the element, independently of the computational domain used on the background mesh.

If a grill has passed through the keyword GRILLE (GRID) (Section 6.4.3.2), the update zone always coincides with the computational domain used on the grid.

If TYPE_GROUP = ‘TORE’, the node will be retained if it is contained in a torus built around the crack tip of radius given by the keyword RAYON_TORE. If the location of the domain was used for the crack calculation, this option cannot be selected. In this case, the group of nodes is created using the update zone (option TYPE_GROUP = ‘ZONE_MAJ’ is automatically selected) and the user’s choice is ignored.

For a precise definition of the notions of enriched node, Heaviside node, Crack-tip node, auxiliary mesh, field of computation and its localization, see R7.02.12, Section 15.2.4.2.5.

6.4.3.5.15. Operand RAYON_TORE (TORUS_RADIUS)

# If TYPE_GROUP = 'TORE'

♦  RAYON_TORE = r

We specify the radius \(r\) of the torus to be used for the selection of the nodes.

6.4.3.5.16. Operand OPTION = ‘RELA_CINE_BP’`(:gray:`RELATION_KINEMATIC_PRESTRESSED_CONCRETE)

For each triplet of connections (3 directions of space) contained in the list of kinematic relations of a concept of type cable_precont resulting from DEFI_CABLE_BP, this option creates a group of nodes containing the cable node and the concrete nodes concerned. The name of this group is the value given to PREF_GRNO followed by the name of the cable node.

♦ CABLE_BP = cable_bp

Name of the cable_precont concept.

♦ PREF_GRNO = pref

Prefix given to the groups of nodes created.

6.4.3.5.17. Operands GROUP_MA and NOM

/ GROUP_MA = l_el_grp
  ◊ NOM = l_no_grp
  ◊ CRIT_NOEUD =  / 'TOUT'                   [DEFAULT]
                  / 'SOMMET'
                  / 'MILIEU'
                  / 'CENTRE'

For each group of elements of the list l_el_grp, a group of nodes formed by nodes carried by the elements of this group is created.

If l_no_grp is supplied by the user, this list must be the same length as l_el_grp. These are the names which one wants to give to the new groups of nodes.

If l_no_grp is not provided, the node groups will bear the same names as the element groups that gave birth to them.

If CRIT_NOEUD (NODE_CRITERION) is ‘TOUT’ (ALL), all the nodes of each element are used.

If CRIT_NOUED = ‘SOMMET’ (VERTEX), only the vertex nodes of each element are used.

If CRIT_NOUED = ‘MILIEU’ (MIDDLE), only the nodes on the middle of edges of each element are used.

If CRIT_NOUED = ‘CENTER’, one takes only the nodes which are neither “vertex” nor “middle”, i.e., the nodes at the center of the faces or the element volume.

6.4.3.5.18. Operand TOUT_GROUP_MA

/ TOUT_GROUP_MA = 'OUI'

This keyword has the same meaning as the previous one, except that we create groups of nodes for all the existing element groups of the mesh.

6.4.3.5.19. Operand ALARME

ALARME = / 'OUI'                         [DEFAULT]
         / 'NON'

If ALARM = ‘NON’, the code does not emit an alarm; for example when asked to create a GROUP_NO and this group is empty. The default value of this keyword is ‘OUI’.

6.4.3.5.20. Operand INFO

If INFO = 1, the number of groups created and the group name and number of entities for each group are printed in the message file.

If INFO = 2, in addition to the information printed for INFO = 1, the list of entities constituting the groups are also printed in the message file.

6.4.4. Examples

Example 1 (topological and logical criteria)

Let mesh be a mesh that already contains the element groups:

el_grp1   el_grp2   el_grp3

and the node groups:

nd_grp1   nd_grp2   nd_grp3
mesh = DEFI_GROUP(reuse = mesh,
                  MAILLAGE = mesh,
                  CREA_GROUP_MA = (_F(NOM = ename1, GROUP_MA = (elem7, elem9, ...)),
                                   _F(NOM = ename2, UNION = (el_grp1, ename1)),
                                   _F(NOM = ename3, DIFFE = (ename2, el_grp2))),
                  CREA_GROUP_NO = _F(TOUT_GROUP_MA = 'OUI'))

mesh = DEFI_GROUP(reuse = mesh,
                  MAILLAGE = mesh,
                  CREA_GROUP_MA = _F(NOM = ename4, GROUP_MA = (elem7, elem11, elem13))
                  CREA_GROUP_NO = (_F(NOM = nname1, INTERSEC = (ename1, nd_grp1)),
                                   _F(GROUP_MA = ename4)))

After these two calls to the command DEFI_GROUP, the mesh then contains:

  • the element groups:

    • el_grp1, el_grp2, el_grp3 (initial)

    • ename1 = (elements: elem7, elem9, …)

    • ename2 = el_grp1 “union” ename1

    • ename3 = ename2 “minus” el_grp2

    • ename4 = (elements: elem7, elem11, elem13)

  • the node groups:

    • nd_grp1, nd_grp2, nd_grp3 (initial)

    • el_grp1, el_grp2, el_grp3, ename1, ename2, ename3: group_no containing the nodes of group_ma of same names. These group_no are created by the first DEFI_GROUP command.

    • nname1 = ename1 “intersection” nd_grp1

    • ename4 = (nodes of group_ma ename4)

Example 2 (geometric criteria)

mesh = DEFI_GROUP(reuse = mesh,
                  MAILLAGE = mesh,
                  CREA_GROUP_MA = (_F(NOM = facesup,
                                      OPTION = 'FACE_NORMALE',
                                      VECT_NORMALE = (0., 0., 1.)),
                                   _F(NOM = ball01,
                                      OPTION = 'SPHERE',
                                      POINT = (0., 0., 0.),
                                      RAYON = 1.)),
                  CREA_GROUP_NO = (_F(NOM = b0_ball01,
                                      OPTION = 'ENV_SPHERE',
                                      POINT = (0., 0., 0.),
                                      RAYON = 1.,
                                      PRECISION = 0.01),
                                   _F(NOM = ball01_1, GROUP_MA = ball01),
                                   _F(NOM = ball01_2,
                                      OPTION = 'ENV_SPHERE',
                                      POINT = (0., 0., 0.),
                                      RAYON = 0.5,
                                      PRECISION = 0.5)))

After DEFI_GROUP the mesh mesh will contain 2 new group_ma and 3 new group_no:

  • facesup contains the facets whose normal is directed according to OZ (towards the Z > 0 ),

  • ball01 contains all the elements of which one of the nodes belongs to the sphere of radius 1 and centered at O (origin of the axes),

  • b0_ball01 is the group of the nodes which are in the vicinity of the envelope of the sphere (ball01),

  • ball01_1 is the group of all the nodes of the elements of the group of elements ball01; Warning :some nodes of this group may be outside the sphere!

  • ball01_2 is the group of the nodes included in the sphere ball01: \(|d(M,O) - 0.5| \le 0.5\).