2.1.1 Node definition

**Products: **ABAQUS/Standard ABAQUS/Explicit

This section describes the methods for defining nodes in an ABAQUS input file. In a preprocessor such as ABAQUS/CAE, you define the model geometry rather than the nodes and elements; when you mesh the geometry, the preprocessor automatically creates the nodes and elements needed for analysis. Although the concepts discussed in this section apply in general to the node definitions in the input file that is created by ABAQUS/CAE, the methods and techniques described here apply only if you are creating the input file manually.

Node definition consists of:

assigning a node number to the node;

optionally specifying a local coordinate system in which to define nodes;

defining individual nodes by specifying their coordinates;

grouping nodes into node sets;

creating nodes from existing nodes by generating them incrementally, by copying existing nodes, or by filling in nodes between the bounds of a region; and

mapping a set of nodes from one coordinate system to another.

ABAQUS will eliminate all unnecessary nodes before proceeding with the analysis. This feature is useful because it allows points to be defined as nodes for mesh generation purposes only.

Assigning a node number to the node

Each individual node must have a numeric label called the node number, which is assigned when the node is defined. The node number must be a positive integer, and the maximum node number allowed is 999999999 (for information on integer input, see “Input syntax rules,” Section 1.2.1). The nodes do not need to be numbered continuously.

An ABAQUS model can be defined in terms of an assembly of part instances (see “Defining an assembly,” Section 2.9.1). In such a model all nodes must belong to either a part, part instance, or, in the case of reference nodes, to the assembly. Node numbers must be unique within a part, part instance, or the assembly; but they can be repeated in different parts or part instances.

Specifying a local coordinate system in which to define nodes

Sometimes it is convenient to define nodal coordinates in a local coordinate system and then transform these coordinates to the global coordinate system. You can define a nodal coordinate system; ABAQUS will translate and rotate the local () coordinate values into the global coordinate system. The transformation is done immediately after input and will be applied to all nodal coordinates entered or generated after the nodal coordinate system is defined.

The transformation affects only the input of nodal coordinates in node definitions. Nodal coordinate system definitions cannot be used

for applying loads and boundary conditions—see “Transformed coordinate systems,” Section 2.1.5, instead; or

for output of components of stress, strain, and element section forces—see “Orientations,” Section 2.2.5, instead.

You set up the coordinate system specification by specifying the global coordinates of three points in the local system: the origin of the local system (point *a* in Figure 2.1.1–1), a point on the local -axis (point *b* in Figure 2.1.1–1), and a point in the plane of the local system on (or near) the local -axis (point *c* in Figure 2.1.1–1).

To change the nodal coordinate system that is in effect, define another nodal coordinate system; to revert to input in the global coordinate system, use a nodal coordinate system definition without any associated data.

Input File Usage: | Use the following option to define a nodal coordinate system: |

*SYSTEM , , , , , , , For example, in the following input, nodes 1 through 3 are defined in the first nodal coordinate system, nodes 4 and 5 are defined in the second nodal coordinate system, and nodes 6 and 7 are defined in the global coordinate system: *SYSTEM 0, 0, 0, 5, 5, 5 *NODE 1, 0, 0, 1 2, 0, 0, 2 3, 0, 1, 2 *SYSTEM 2, 3, 4 *NODE 4, 0, 0, 1 5, 1, 4, 0 *SYSTEM *NODE 6, 1, 0, 1 7, 0, 4, 2 |

When you define a nodal coordinate system within a part (or part instance) definition, it is in effect only within that part (or part instance) definition. Nodes defined in other parts are not affected.

You specify the local () coordinate values relative to the part coordinate system, which subsequently may be translated and/or rotated according to the positioning data given for the instance (see “Defining an assembly,” Section 2.9.1).

Defining individual nodes by specifying their coordinates

You can define individual nodes by specifying the node number and the coordinates that define the node. ABAQUS uses a right-handed, rectangular Cartesian coordinate system for all nodes except for axisymmetric models, when the coordinates of the nodes must be given as the radial and axial positions. For more information about direction definitions, see “Conventions,” Section 1.2.2.

In a model defined in terms of an assembly of part instances, give nodal coordinates in the local coordinate system of the part (or part instance). See “Defining an assembly,” Section 2.9.1.

Input File Usage: | *NODE |

Node definitions can be read into ABAQUS from an alternate file. The syntax of such file names is described in “Input syntax rules,” Section 1.2.1.

Input File Usage: | *NODE, INPUT= |

You can specify that a local rectangular Cartesian, cylindrical, or spherical coordinate system be used for a particular node definition. These coordinate systems are shown in Figure 2.1.1–2.

This coordinate system specification is entirely local to the node definition. As the nodal data are read, the coordinates are transformed to rectangular Cartesian coordinates immediately. If a nodal coordinate system is also in effect (see “Specifying a local coordinate system in which to define nodes”), these are local rectangular Cartesian coordinates as defined by the nodal coordinate system, which are subsequently transformed to global Cartesian coordinates.

Input File Usage: | Use the following option to specify the nodal coordinates in a rectangular Cartesian system (this is the default): |

*NODE, SYSTEM=R Use the following option to specify the nodal coordinates in a cylindrical system: *NODE, SYSTEM=C Use the following option to specify the nodal coordinates in a spherical system: *NODE, SYSTEM=S For example, the following lines define node number 1 with coordinates (10cos20°, 10sin20°, 5.) in a local cylindrical system ( *NODE, NSET=DISC, SYSTEM=C 1, 10., 20., 5. If the following lines appeared in the input file before the above node definition, the coordinates of node 1 would be transformed first to rectangular Cartesian coordinates in the nodal coordinate system defined by the *SYSTEM option and then to coordinates in the global system: *SYSTEM 2, 0, 2 |

Grouping nodes into node sets

Node sets are used as convenient cross-references when defining loads, constraints, properties, etc. Node sets are the fundamental references of the model and should be used to assist the input definition. The members of a node set can be individual nodes or other node sets. An individual node can belong to several node sets.

Nodes can be grouped into node sets when they are created or after they have already been defined. In either case each node set is assigned a name. Node set names can be up to 80 characters long.

The same name can be used for a node set and for an element set.

By default, the nodes within a node set will be arranged in ascending order, and duplicate nodes will be removed. Such a set is called a sorted node set. You may choose to create an unsorted node set as described later, which is often useful for features that match two or more node sets. For example, if you define multi-point constraints (“General multi-point constraints,” Section 28.2.2) between two node sets, a constraint will be created between the first node in Set 1 and the first node in Set 2, then between the second node in Set 1 and the second node in Set 2, etc. It is important to ensure that the nodes are combined in the desired way. Therefore, it is sometimes better to specify that a node set be stored in unsorted order.

Once nodes are assigned to a node set, additional nodes can be added to the same node set; however, nodes cannot be removed from a node set.

You can choose to assign nodes to a new node set (or to add nodes to an existing node set) in the order in which they are given. The node numbers will not be rearranged, and duplicates will not be removed.

This unsorted node set will affect node copies, node fills, linear constraint equations, multi-point constraints, and substructure nodes associated with retained degrees of freedom. An unsorted node set can be created only by directly defining an unsorted node set as described here or by copying an unsorted node set. Any additions or modifications to a node set using other means will result in a sorted node set.

Input File Usage: | *NSET, NSET= |

There are several ways that nodes can be assigned to node sets as they are created.

You can assign nodes that you have defined previously (by specifying their coordinates, by filling in nodes between two bounds, or by generating them incrementally) to a node set by listing the nodes forming the set directly, by generating the node set, or by generating a node set from an element set.

You can list the nodes that form a node set directly. Previously defined node sets, as well as individual nodes, can be assigned to node sets.

Input File Usage: | *NSET, NSET= |

For example, the following lines add nodes 1, 3, 10, 11, and all the nodes in set A11 to set A12:*NSET, NSET=A12 1, 3 10, 11, A11 Node set All the nodes in node set |

To generate a node set, you must specify a first node, ; a last node, ; and the increment in node numbers between these nodes, *i*. All nodes going from to in increments of *i* will be added to the set. Therefore, *i* must be an integer such that is a whole number (not a fraction). The default is .

You can specify the name of a previously defined element set (“Element definition,” Section 2.2.1), in which case the nodes that define the elements contained in this element set will be assigned to the specified node set. This method can be used only to define sorted node sets.

Input File Usage: | *NSET, NSET= |

For example, the following lines add all nodes that define elements 50 and 100 (nodes 1, 2, 3, and 4) to node set A14:*ELEMENT, TYPE=B21 50, 1, 2 100, 3, 4 *ELSET, ELSET=B1 50, 100 *NSET, NSET=A14, ELSET=B1 Element set |

In a model defined in terms of an assembly of part instances, all node sets must be defined within a part, part instance, or the assembly definition. If a node set is defined within a part (or part instance) definition, you can refer to the node numbers directly. To define an assembly-level node set, you must identify the nodes to be added to the set by prefixing each node number with the part instance name and a “.” (as explained in “Defining an assembly,” Section 2.9.1). An assembly-level node set can have the same name as a part-level node set.

The following input defines a node set, `set1`, that belongs to part `PartA` and will be inherited by every instance of `PartA`:

*PART, NAME=PartA ... *NSET, NSET=set1 1,3,26,500 *END PARTA node set with the same name is defined at the assembly level as follows:

*ASSEMBLY, NAME=Assembly-1 *INSTANCE, NAME=PartA-1, PART=PartA ... *END INSTANCE *INSTANCE, NAME=PartA-2, PART=PartA ... *END INSTANCE *NSET, NSET=set1 PartA-1.1, PartA-1.3, PartA-1.26, PartA-1.500 PartA-2.1, PartA-2.3, PartA-2.26, PartA-2.500 *END ASSEMBLYAssembly-level node set

*ASSEMBLY, NAME=Assembly-1 *INSTANCE, NAME=PartA-1, PART=PartA ... *END INSTANCE *INSTANCE, NAME=PartA-2, PART=PartA ... *END INSTANCE *NSET, NSET=set1 PartA-1.set1, PartA-2.set1 *END ASSEMBLYThis node set definition is equivalent to the previous example, where the nodes are listed individually.

Sometimes it is not convenient to define an assembly-level node set by referring to part-level node sets. In such cases a set definition containing many nodes can get quite lengthy. Therefore, an alternate method is provided.

Input File Usage: | *NSET, NSET= |

The following example shows two equivalent ways to define an assembly-level node set; once by prefixing each node number with a part instance name (as shown above) and once using the more compact INSTANCE notation: *ASSEMBLY, NAME=Assembly-1 *INSTANCE, NAME=PartA-1, PART=PartA ... *END INSTANCE *INSTANCE, NAME=PartA-2, PART=PartA ... *END INSTANCE *NSET, NSET=set2 PartA-1.11, PartA-1.12, PartA-1.13, PartA-1.14, PartA-2.21, PartA-2.22, PartA-2.23, PartA-2.24 *NSET, NSET=set3, INSTANCE=PartA-1 11, 12, 13, 14 *NSET, NSET=set3, INSTANCE=PartA-2 21, 22, 23, 24 *END ASSEMBLY When the *NSET option is used more than once with the same name, as it is with |

In ABAQUS/CAE many modeling operations are performed by picking geometry with the mouse. For example, a concentrated load can be applied by picking a point on a geometric part instance. Since the *CLOAD option refers to a node set, this “picked” geometry must be translated into a node set in the input file. Such sets are assigned a name by ABAQUS/CAE and marked as internal. You can view these internal sets using display groups in the Visualization module of ABAQUS/CAE (see Chapter 52, “Using display groups to display subsets of your model,” of the ABAQUS/CAE User's Manual).

Input File Usage: | *NSET, NSET= |

Transferring of node sets

If the results of an ABAQUS/Explicit analysis are imported into an ABAQUS/Standard analysis (or vice versa) or results from an ABAQUS/Standard analysis are imported into another ABAQUS/Standard analysis (see “Transferring results between ABAQUS analyses: overview,” Section 9.2.1), all node set definitions in the original analysis are imported by default. Alternatively, you can import only selected node set definitions; see “Importing element set and node set definitions” in “Transferring results between ABAQUS analyses: overview,” Section 9.2.1, for details.

If a three-dimensional model is generated from a symmetric model (see “Symmetric model generation,” Section 10.3.1), all node sets in the original model will be used (and expanded) in the generated model.

Creating nodes from existing nodes by generating them incrementally

You can generate nodes incrementally from existing nodes. All of the nodes along a straight or curved line can be generated by giving the coordinates of the two end nodes and defining the type of curve.

The two end nodes must already be defined, usually by specifying their coordinates, but it is also possible to have them defined by an earlier generation.

To define a straight line between the two end nodes, specify the number of the first end node, ; the number of the last end node, ; and the increment in node numbers between each node along the line, *i*. Therefore, *i* must be an integer such that is a whole number (not a fraction). The default is .

Input File Usage: | *NGEN |

For example, in the following input node number 1 with coordinates (0., 0., 0.) and node number 6 with coordinates (10., 0., 0.) are defined and nodes 2, 3, 4, and 5 with coordinates (2., 0., 0.), (4., 0., 0.), (6., 0., 0.), and (8., 0., 0.), respectively, are generated automatically: *NODE 1, 0., 0., 0. 6, 10., 0., 0. *NGEN 1, 6, 1 |

To define a circular arc between the two end nodes, specify the number of the first end node, ; the number of the last end node, ; and the increment in node numbers between each node along the arc, *i*. Therefore, *i* must be an integer such that is a whole number (not a fraction). The default is .

In addition, you must specify the coordinates of one extra point, the center of the circle, either by giving the node number of a node that has already been defined or by giving the nodal coordinates directly. If both are supplied, the node number will take precedence over the coordinates.

If the coordinates are defined directly, they can be specified in a local coordinate system as described later.

The coordinates of the end nodes will be adjusted radially if the circle cannot be passed through both points. An arc of a circle of 180° through 360° will require more extensive definition. For this case you must define the plane of the circular disc by giving the normal to the disc; the nodes will then be numbered according to the right-hand rule about this normal.

Input File Usage: | *NGEN, LINE=C |

To define a parabola between the two end nodes, specify the number of the first end node, ; the number of the last end node, ; and the increment in node numbers between each node along the parabola, *i*. Therefore, *i* must be an integer such that is a whole number (not a fraction). The default is .

In addition, you must specify the coordinates of one extra point, the midpoint on the arc between the two end points, either by giving the node number of a node that has already been defined or by giving the nodal coordinates directly. If both are supplied, the node number will take precedence over the coordinates.

If the coordinates are defined directly, they can be specified in a local coordinate system as described later.

Input File Usage: | *NGEN, LINE=P |

You can specify the coordinates of the extra point that is required for a circle or a parabola in a local rectangular Cartesian system, a cylindrical system, or a spherical system. These coordinate systems are shown in Figure 2.1.1–2.

If a nodal coordinate system is in effect (see “Specifying a local coordinate system in which to define nodes”), the coordinates and normal direction specified in the node definition are assumed to be in the nodal coordinate system. If a nodal coordinate system is in effect and you specify the extra point for a circle or parabola in a local coordinate system, the input is first transformed according to the local system specified in the node definition and subsequently according to the nodal coordinate system.

Input File Usage: | Use the following option to specify the extra point in a rectangular Cartesian system (this is the default): |

*NGEN, SYSTEM=RC Use the following option to specify the extra point in a cylindrical system: *NGEN, SYSTEM=C Use the following option to specify the extra point in a spherical system: *NGEN, SYSTEM=S |

Creating nodes by copying existing nodes

You can create new nodes by copying existing nodes. The coordinates of the new nodes can be translated and rotated, reflected from the nodes being copied, or projected from the nodes being copied by using a polar projection with respect to a pole node.

You must identify the existing node set to copy and specify an integer constant, *n*, that will be added to the node numbers of existing nodes to define node numbers for the nodes being created.

You can assign the newly created nodes to a node set. If you do not specify a node set name for the newly created nodes, they are not assigned to a node set.

Input File Usage: | *NCOPY, OLD SET= |

You can create new nodes by translating and/or rotating the nodes in the old node set (see Figure 2.1.1–3). You specify the value of the translation in the *X*-, *Y*-, and *Z*-directions.

In addition, you specify the coordinates of the first point defining the rotation axis (point *a* in Figure 2.1.1–3), the coordinates of the second point defining the rotation axis (point *b* in Figure 2.1.1–3), and the angle of rotation (in degrees) about the *a*–*b* axis. The rotation can be applied multiple times as described later.

If you specify both translation and rotation, the translation is applied once before the rotation.

Input File Usage: | *NCOPY, OLD SET= |

You can specify the number of times the rotation should be applied, *m*. For example, if nodes are to be created at angles of 30°, 60°, and 90°, set *m*=3. The identifiers of the nodes created are incremented sequentially by the value of *n*, as described above.

Input File Usage: | *NCOPY, OLD SET= |

You can create new nodes by reflecting the coordinates of the old nodes through a line, a plane, or a point.

To reflect the old nodal coordinates through a line, you specify the coordinates of points *a* and *b* (see Figure 2.1.1–4).

Input File Usage: | *NCOPY, OLD SET= |

To reflect the old nodal coordinates through a plane, you specify the coordinates of points *a*, *b*, and *c* (see Figure 2.1.1–5).

Input File Usage: | *NCOPY, OLD SET= |

To reflect the old nodal coordinates through a point, you specify the coordinates of point *a* (see Figure 2.1.1–6).

Input File Usage: | *NCOPY, OLD SET= |

You can create new nodes by projecting the nodes in the old set from a pole node. Each new node will be located such that the corresponding old node is equidistant between the pole node and the new node. The pole node (see Figure 2.1.1–7) is identified by giving its number or, alternatively, its coordinates.

This method is particularly useful for creating nodes that are associated with infinite elements (“Infinite elements,” Section 22.2.1). In this case the pole node should be located at the center of the far-field solution.

Input File Usage: | *NCOPY, OLD SET= |

Creating nodes by filling in nodes between two bounds

You can create nodes by filling in nodes between two bounds. In this case you specify the two node sets whose members form the bounds, the number of intervals along each line between the bounding nodes, and the increment in node numbers from the node number at the first bound set end.

Let *l* equal the number of lines of nodes to be created between the two bounding node sets; the number of intervals along each line between the bounding nodes is then given by .

Let *n* equal the increment in node numbers from the node number at the first bound set end; for each node () in the first bounding node set, the corresponding node in the other bounding node set () must be numbered such that is a whole number.

The node sets that define the bounds of the region are used as they exist at the time the node fill definition appears in the input file: only those nodes that have been added to the sets prior to the node fill definition are used. Both sorted and unsorted node sets can be used. Nodes that have not yet been given coordinates are assumed to be at the origin, (0.,0.,0.).

The nodes created by this method lie on straight lines between corresponding nodes in the two sets. If the sets do not have the same number of nodes, the extra nodes in the longer set are ignored. By default, the spacing between nodes along the lines is uniform.

Input File Usage: | *NFILL |

For example, Figure 2.1.1–8 shows a simple quarter-cylinder model.

The quarter circles*NFILL, NSET=A INSIDEA, OUTSIDEA, 4, 100 *NFILL, NSET=B INSIDEB, OUTSIDEB, 4, 100 *NFILL A, B, 5, 1000

You can concentrate the nodes toward one bound or the other by specifying *b*, the ratio of adjacent distances between nodes along each line of nodes generated as the nodes go from the first bounding node set to the second.

Thus, if *b* is less than one, the nodes are concentrated toward the first bounding node set; if *b* is greater than one, the nodes are concentrated toward the second bounding set. The value of *b* must be positive.

The bias intervals along the line from the first bounding node are *L*, , , , , , … (where *L* is the length of the first interval). In ABAQUS/Standard the bias value can be applied at every interval along the line or at every second interval along the line as described later.

Input File Usage: | *NFILL, BIAS= |

For example, suppose the lines of nodes shown in Figure 2.1.1–9 have already been generated by other methods and placed into node sets `INSIDE` and `OUTSIDE`.

*NFILL, BIAS=0.6 INSIDE, OUTSIDE, 5, 100

In ABAQUS/Standard you can apply the bias value at every second interval along the line. In this case the nodes will be positioned along the line correctly for use with second-order elements, so that the midside nodes are at the middle of the interval between the corner nodes of the elements.

The bias intervals along the line from the first bounding node are *L*, *L*, , , , , … (where *L* is the length of the first interval).

Input File Usage: | *NFILL, BIAS= |

In ABAQUS/Standard you can create quarter-point spacing for fracture mechanics calculations with second-order isoparametric elements (“Fracture mechanics: overview,” Section 11.4.1). This spacing gives a square root singularity in the strain field at the crack tip by placing the first node away from that point at one-quarter of the distance to the second point. The remaining nodes on each line are spaced so that the size of the elements will grow as the square of the distance from the singularity, with the midside nodes exactly at the midsides of the elements. This spacing produces a reasonable mesh gradation for this type of problem; however, better results can be obtained for crude meshes by making the size of the crack element smaller than the quarter-point spacing technique does.

Input File Usage: | *NFILL, SINGULAR |

Figure 2.1.1–11 shows a simple fracture mechanics example.

(The mesh shown is very coarse, and a finer mesh would probably be used in an actual case.) The nodes on the top edge have been placed in node set*NFILL, BIAS=0.8 MID, TOP, 4, 100 *NFILL, SINGULAR=1 TIP, OUTER, 5, 20

Mapping a set of nodes from one coordinate system to another

You can map a set of nodes from one coordinate system to another. This capability is useful for many geometric situations: a mesh can be generated quite easily in a local coordinate system (for example, on the surface of a cylinder) using other methods and then can be mapped into the global (*X*, *Y*, *Z*) system.

The mapping capability cannot be used in a model defined in terms of an assembly of part instances.

The following different mappings are provided: a simple shift and/or rotation; skewed Cartesian; cylindrical; spherical; toroidal; and, in ABAQUS/Standard only, blended quadratic. The first five of these mappings are shown in Figure 2.1.1–13. Blended quadratic mapping is shown in Figure 2.1.1–14.

In all cases the coordinates of the nodes in the set are assumed to be defined in the local system: these local coordinates at each node are replaced with the global Cartesian (*X*, *Y*, *Z*) coordinates defined by the mapping. All angular coordinates should be given in degrees.

The mapping capability can be used several times in succession on the same nodes, if required.

For all mappings except the blended quadratic mapping, you can specify a scaling factor to be applied to the local coordinates before they are mapped.

This facility is useful for “stretching” some of the coordinates that are given. For example, in cases where the local system uses some angular coordinates and some distance coordinates (cylindrical, spherical, etc.), it may be preferable to generate the mesh in a system that uses distance measures in the angular directions and then scale onto the angular coordinate system for the mapping.

Input File Usage: | *NMAP, NSET= |

In the case of a simple shift and/or rotation, point *a* in Figure 2.1.1–13 defines the origin of the local rectangular coordinate system defining the map. The local -axis is defined by the line joining points *a* and *b*. The local – plane is defined by the plane passing through points *a*, *b*, and *c*.

Input File Usage: | *NMAP, NSET= |

For mapping from cylindrical coordinates, point *a* in Figure 2.1.1–13 defines the origin of the local cylindrical coordinate system defining the map. The line going through point *a* and point *b* defines the -axis of the local cylindrical coordinate system. The local – plane for is defined by the plane passing through points *a*, *b*, and *c*.

Input File Usage: | *NMAP, NSET= |

For mapping from skewed Cartesian coordinates, point *a* in Figure 2.1.1–13 defines the origin of the local diamond coordinate system defining the map. The line going through point *a* and point *b* defines the -axis of the local coordinate system. The line going through point *a* and point *c* defines the -axis of the local coordinate system. The line going through point *a* and point *d* defines the -axis of the local coordinate system.

Input File Usage: | *NMAP, NSET= |

For mapping from spherical coordinates, point *a* in Figure 2.1.1–13 defines the origin of the local spherical coordinate system defining the map. The line going through point *a* and point *b* defines the polar axis of the local spherical coordinate system. The plane passing through point *a* and perpendicular to the polar axis defines the plane. The plane passing through points *a*, *b*, and *c* defines the local plane.

Input File Usage: | *NMAP, NSET= |

For mapping from toroidal coordinates, point *a* in Figure 2.1.1–13 defines the origin of the local toroidal coordinate system defining the map. The axis of the local toroidal system lies in the plane defined by points *a*, *b*, and *c*. The *R*-coordinate of the toroidal system is defined by the distance between points *a* and *b*. The line between points *a* and *b* defines the position. For every value of the -coordinate is defined in a plane perpendicular to the plane defined by the points *a*, *b*, and *c* and perpendicular to the axis of the toroidal system. lies in the plane defined by the points *a*, *b*, and *c*.

Input File Usage: | *NMAP, NSET= |

To map by means of blended quadratics in ABAQUS/Standard, you define the new (mapped) coordinates of up to 20 “control nodes”: these are the corner and midedge nodes of the block of nodes being mapped. The mapping in this case is like that of a 20-node brick isoparametric element. Any of the midedge nodes can be omitted, thus allowing linear interpolation along that edge of the block. ABAQUS/Standard does not check whether the nodes in the set lie within the physical space of the block defined by the corner and midedge nodes: these control nodes simply define mapping functions that are then applied to all of the nodes in the set.

The control nodes should define a “well”-shaped block; for example, midedge nodes should be close to the midpoint of the edge. Otherwise, the mapping can be very distorted. For example, the nodes of a crack-tip 20-node element with midside nodes at the quarter points will not map correctly and, therefore, should not be used as the control nodes.

Input File Usage: | *NMAP, NSET= |