Skip to content

Constraint Commands

Constraints are defined using *Constraint. Each constraint has a unique name, and duplicate names are not allowed. Constraints include both narrow definitions such as single-point constraints (e.g., support conditions) and multi-point constraints, as well as broader concepts that apply limitations to finite element objects like boundaries or connections. Examples include viscous boundaries or linear springs acting on surfaces without material property changes during the analysis step. Unlike *Load, constraints are immediately applied and removed within a *Step and do not change characteristics within that step.

Hyfeast uses an automatic selection of slave DOF and over-constraint handling, so common issues in other finite element programs, such as over-constraint problems or the inability to use slave DOFs in multiple constraints, do not occur.

*Constraint

Define constraints based on the given type.

*Constraint, Type=type, Name=name
  ...
Keyword line

  • Type=type: Specifies the type of constraint. Options include RigidLink, BeamLink, MPC, NodeToSurface, etc.

    • Support: Fixed boundary condition (always zero displacement).
    • RigidLink: Constrains corresponding DOFs between two nodes.
    • BeamLink: Constrains DOFs considering rotation between two nodes.
    • NodeToSurface: Constrains nodes, nsets, or surface nodes to another surface.
    • MPC: User-defined linear multi-point constraint.
    • Embedded: Embeds nodes in the host elements.
    • Spring: Connects nodes with springs or dampers.
    • EarthSpring: Connects nodes with ground springs or dampers.
    • SpringBoundary: Applies springs/dampers to a surface or line (beam or truss elements).
    • ViscousBoundary: Models a viscous boundary.
    • AcousticImpedance: Models an impedance boundary for acoustic elements.
    • AcousticSolidLink: Models a linkage between acoustic and solid elements.

  • Name=name: Unique name of the constraint.

*Constraint, Type=Support

Defines fixed boundary conditions (zero displacement).

*Constraint, Type=Support, Name=name
  targetNode, dof, CS=orientation
  targetNGroup, dof, CS=orientation
  ...
First data line and subsequent data lines
  • targetNode: Node for support boundary condition (required).
  • targetNGroup: Node group for support boundary condition(required). The targetNGroup can be specified as an nset, a surface, or a node number pattern (start:end:spacing, with spacing=1 being optional). If a surface is specified, it refers to all nodes that belong to that surface.
  • dof: The DOF to constrain. Can be X, Y, Z, RX, RY, RZ, or combinations like X|Y (required).
  • CS=orientation: Coordinate system in which the support condition is applied. Specify the name defined via *CoordinateSystem, TYPE=Orientation. If omitted, the global coordinate system (GCS) is used. (optional)

The first entry in the data line searches for possible targets in the order of nset, surface, node number pattern, or node number. Note that predefined nset or surface names may consist of numbers, so caution is required.

If the same DOF is specified multiple times, only one constraint is applied without error.

A local coordinate system can be specified to define inclined boundary conditions. Internally, this is handled by imposing a multi-point constraint (MPC). Output results are provided in the GCS by default. If results are needed in the local coordinate system, this must be explicitly specified in the *Print or *History commands. The *Output command does not support specifying a local coordinate system, but hfVisualizer allows postprocessing and conversion of results into a local coordinate system.

Example
*Constraint, Type=Support, Name=initialBC
 1, X|Y
 all, Z|RX|RY      # all is NSET
 topTopSurface, Z  # topTopSurface is Surface
 201:207:3, Y      # 201:207:3 is a pattern with 201, 204, 207

*Constraint, Type=Support, Name=C
 101, X
 101, X   # OK, but neglected

*CoordinateSystem, TYPE=Orientation, Name=inc
 1,1,0, 0,1,0

*Constraint, Type=Support, Name=initialBC
 1, X|Y
 5, X, CS=inc

Constrains corresponding DOFs between two nodes.

*Constraint, Type=RigidLink, Name=name
 slaveNode, masterNode, dof
 slaveNGroup, masterNode, dof
 slaveNGroup, masterNGroup, dof
 ...
First data line and subsequent data lines
  • slaveNode, masterNode: the two nodes to be linked (required)
  • slaveNGroup, masterNode: connects all nodes in the slaveNGroup to the masterNode (required). The slaveNGroup can be specified as an nset, a surface, or a node number pattern (start:end:spacing, with spacing=1 being optional). If a surface is specified, it refers to all nodes that belong to that surface.
  • slaveNGroup, masterNGroup: the two node groups to be linked (required). The closest nodes in each group are matched in a 1:1 manner, so the number of nodes in both groups must be identical. As an exception, if the masterNGroup contains only a single node, this is equivalent to specifying slaveNGroup, masterNode, where all nodes in the slaveNGroup are matched to the sole node in the masterNGroup. Both slaveNGroup and masterNGroup can be specified as an nset, a surface, or a node number pattern (start:end:spacing, with spacing=1 being optional). If a surface is specified, it refers to all nodes that belong to that surface.
  • dof: DOF to constrain (required). The DOF can be X, Y, Z, RX, RY, RZ, P, etc. Can be combinations like X|RX, Y|RZ, etc.

The *Constraint, TYPE=RigidLink command simply constrains the corresponding DOFs between two nodes.

When using node groups such as slaveNGroup or masterNGroup, each group searches for possible targets in the order of nset, surface, node number pattern, or node number. Note that predefined nset or surface names may consist of numbers, so caution is required.

Example
*Constraint, Type=RigidLink Name=c1
 1, 2, X|Y|Z
 left, right, X
 1:10:2, 101:110:2, Y|RX

Constrains DOFs between two nodes considering rotation.

*Constraint, Type=BeamLink, Name=name
 slaveNode, masterNode, plane
 slaveNGroup, masterNode, plane
 slaveNGroup, masterNGroup, plane
 ...
First data line and subsequent data lines
  • slaveNode, masterNode: the two nodes to be linked (required)
  • slaveNGroup, masterNode: connects all nodes in the slaveNGroup to the masterNode (required). The slaveNGroup can be specified as an nset, a surface, or a node number pattern (start:end:spacing, with spacing=1 being optional). If a surface is specified, it refers to all nodes that belong to that surface.
  • slaveNGroup, masterNGroup: the two node groups to be linked (required). The closest nodes in each group are matched in a 1:1 manner, so the number of nodes in both groups must be identical. As an exception, if the masterNGroup contains only a single node, this is equivalent to specifying slaveNGroup, masterNode, where all nodes in the slaveNGroup are matched to the sole node in the masterNGroup. Both slaveNGroup and masterNGroup can be specified as an nset, a surface, or a node number pattern (start:end:spacing, with spacing=1 being optional). If a surface is specified, it refers to all nodes that belong to that surface.
  • plane: Plane to constrain (XY, YZ, ZX, or NOPLANE). Default is NOPLANE.

The *Constraint, TYPE=BeamLink command constrains the DOFs between two nodes considering rotational freedom to simulate rigid body motion. As shown in the figure, it can be used to connect the nodes of a shell to the nodes of a beam when modeling a shell reinforced with beams, or to connect beams that are aligned in parallel.

When using node groups such as slaveNGroup or masterNGroup, each group searches for possible targets in the order of nset, surface, node number pattern, or node number. Note that predefined nset or surface names may consist of numbers, so caution is required.

Example
*Constraint, Type=BeamLink, Name=c1
 1001, 1002, XY
 left, right
 1:10:2, 101:110:2

*Constraint, Type=NodeToSurface

Constrains nodes, nsets, or surface nodes to another surface.

*Constraint, Type=NodeToSurface, Name=name
 slaveNode, masterSurface, dof, radius, searchFlag, springCoef
 slaveNGroup, masterSurface, dof, radius, searchFlag, springCoef
 ...
First data line and subsequent data lines
  • slaveNode: Slave node (required).
  • slaveNGroup: Node group used as slave node (required). The slaveNGroup can be specified as an nset, a surface, or a node number pattern (start:end:spacing, with spacing=1 being optional). If a surface is specified, it refers to all nodes that belong to that surface.
  • masterSurface: Master surface (required).
  • dof: Degrees of freedom to be constrained (required), using combinations such as X, Y, Z. For example, X|Y.
  • radius: Effective perpendicular radius from the slave node to the master surface. A value of 0 means infinite radius, implying that no effective perpendicular radius is applied. Default is 0.
  • searchFlag: Option for finding perpendiculars, one of One, OneF, All, AllF. Default is One. One applies the constraint to the closest perpendicular found, while All applies the constraint to all found perpendiculars. OneF and AllF correspond to One and All, respectively, but if no perpendicular is found, the constraint is applied to the line segment connecting to the nearest node (F indicates failure handling).
  • springCoef: Spring coefficient between the slave node and the perpendicular. A value of 0 means no spring is applied and the constraint is directly imposed. Default is 0.

*Constraint, TYPE=NodeToSurface searches for perpendiculars from the slave node to the master surface and imposes constraints accordingly. When specifying slaveNset or slaveSurface, each individual node belonging to them is treated as a slave node. The first entry in the data line is checked in the order of slaveNset, slaveSurface, and slaveNode. Since nset and surface are provided as strings, be careful when defining their names. Currently, this works only for translational DOFs.

Through radius and searchFlag, the method of searching for perpendiculars and applying constraints can be finely controlled. A radius of 0 means that no effective perpendicular radius is specified, so perpendiculars are searched for against all faces composing the master surface. If radius has a value, only perpendiculars within that distance are considered valid. If exactly one perpendicular is found, the constraint is applied regardless of the searchFlag. If multiple perpendiculars are found, One and OneF select only the closest one, while All and AllF apply the constraint to all of them. If no perpendicular is found, OneF and AllF treat the nearest node as the footprint. If no valid connection can be established, the constraint is not applied, and a warning message is written to the log file.

Perpendicular searching is performed via the Newton method on each face composing the master surface, which can be computationally expensive. To improve efficiency, if radius is specified, the search is performed only on faces where at least one of their nodes lies within 2*radius.

When springCoef is specified, a spring is placed between the slave DOF and the perpendicular. If a sufficiently large spring coefficient is used, constraints can be treated using a penalty method. However, the spring constant applied must be chosen by the user based on eigenfrequency analysis or other suitable methods.

Example
*NSet, Name=slabLine
 ...

*NSet, Name=mygirder
 ...

*Geometry, Type=Surface, Name=slaveSurface
 ...

*Geometry, Type=Surface, Name=slab
 ...


*Constraint, Type=NodeToSurface, Name=C
 slabLine, slab, X|Y|Z
 slaveSurface, slab, X|Y|Z, 0.3, AllF
 mygirder, slab, X|Y|Z, 0.3, OneF
 1:10, slab, X|Y|Z

*Constraint, Type=MPC

Defines user-defined linear multi-point constraints.

*Constraint, Type=MPC, Name=name
  nodal_expression
  ...
  NGroup1, NGroup2, matching_expression
  ...
First data line and subsequent data lines
  • nodal_expression: Define one multi-point constraint condition as a string (required).
  • nset1, nset2, matching_expression: Generate constraints for each node pair in the two nsets (required).
  • NGroup1, NGroup2, matching_expression: Generate multi-point constraint conditions of each node pair given by two NGroup1 and NGroup2(required). Both NGroup1 and NGroup2 can be specified as an nset, a surface, or a node number pattern (start:end:spacing, with spacing=1 being optional). If a surface is specified, it refers to all nodes that belong to that surface.

When specifying nodal_expression

The relationship between nodal degrees of freedom is defined as a linear combination. For example, in the expression 2*X2-3*Y3-5*X4, X2 refers to the X degree of freedom of node 2, Y3 refers to the Y degree of freedom of node 3, and X4 refers to the X degree of freedom of node 4. A constraint is imposed so that this expression equals zero.

When specifying matching_expression

This option can be applied only when the two node sets have the same size. The closest pairs of nodes from the two sets are selected, and the specified constraint is imposed. For example, in the expression 2*X1-3*Y2-5*X1, X1 refers to the X degree of freedom of a node in the first node set, and Y2 refers to the Y degree of freedom of a node in the second node set. The number following the degree-of-freedom symbols (X, Y, Z, RX, RY, RZ, etc.) must be either 1 or 2.

When using node groups such as NGroup1 or NGroup2, each group searches for possible targets in the order of nset, surface, node number pattern, or node number. Note that predefined nset or surface names may consist of numbers, so caution is required.

Example
*Constraint, Type=MPC, Name=Y-Lock
 Y3 - 4*Y4 – 3*RX2              # nodal expression
 left, right, Y1-Y2             # matching expression
 1:3, 101:103, 2*X1-3*Y2-5*X1   # matching expression

*Constraint, Type=Embedded

Embeds nodes into host elements.

*Constraint, Type=Embedded, Name=name
 targetNode, hostElset
 targetNGroup, hostElset
 ...
First data line and subsequent data lines
  • targetNode: Node for support boundary condition (required).
  • targetNGroup: Node group for support boundary condition(required). The targetNGroup can be specified as an nset, a surface, or a node number pattern (start:end:spacing, with spacing=1 being optional). If a surface is specified, it refers to all nodes that belong to that surface.
  • hostElset: Host elset

The *Constraint, TYPE=Embedded command embeds nodes into host elements by finding the host element that contains the node and constraining the node based on the host element's shape function. This is often used to model reinforcement bars within solid elements.

The first entry in the data line searches for possible targets in the order of nset, surface, node number pattern, or node number. Note that predefined nset or surface names may consist of numbers, so caution is required.

Example
*Element, TYPE=T3D2
 1, 1,2
 2, 2,3

*NSET, Name=LineNodes
 1,2,3

*Constraint, TYPE=Embedded, Name=embed
 LineNodes, beam

*Constraint, Type=Spring

Connects nodes with springs or dampers.

*Constraint, Type=Spring, Name=name
 slaveNode, masterNode, K=kx,ky,kz, C=cx,cy,cz, CS=cs
 slaveNGroup, masterNode, K=kx,ky,kz, C=cx,cy,cz, CS=cs
 slaveNGroup, masterNGroup, K=kx,ky,kz, C=cx,cy,cz, CS=cs
 ...
First data line and subsequent data lines
  • slaveNode, masterNode: the two nodes to be connected by spring/damper (required)
  • slaveNGroup, masterNode: connects all nodes in the slaveNGroup to the masterNode by spring/damper (required). The slaveNGroup can be specified as an nset, a surface, or a node number pattern (start:end:spacing, with spacing=1 being optional). If a surface is specified, it refers to all nodes that belong to that surface.
  • slaveNGroup, masterNGroup: the two node groups to be connected by spring/damper (required). The closest nodes in each group are matched in a 1:1 manner, so the number of nodes in both groups must be identical. As an exception, if the masterNGroup contains only a single node, this is equivalent to specifying slaveNGroup, masterNode, where all nodes in the slaveNGroup are matched to the sole node in the masterNGroup. Both slaveNGroup and masterNGroup can be specified as an nset, a surface, or a node number pattern (start:end:spacing, with spacing=1 being optional). If a surface is specified, it refers to all nodes that belong to that surface.
  • K=kx, ky, kz: Spring constants in each direction [F/L]. Default is 0.
  • C=cx, cy, cz: Damping coefficients in each direction [F*T/L]. Default is 0.
  • CS=cs: Coordinate system for the springs(*CoordinateSystem, TYPE=Orientation). If not specified, GCS is used.

Unlike *Element, TYPE=Spring, no element IDs are required. However, only linear springs/dampers are supported.

When using node groups such as slaveNGroup or masterNGroup, each group searches for possible targets in the order of nset, surface, node number pattern, or node number. Note that predefined nset or surface names may consist of numbers, so caution is required.

Example
*Constraint, TYPE=Spring, Name=connection1
 L1, L2, K=0,100,100
 L3, L4, K=0,100,100

*CoordinateSystem, Type=Orientation, Name=cs1
  2,1,0
  3,0,1

*Constraint, TYPE=Spring, Name=connection2
 bottomNodes, topNodes, K=0,100,100, CS=cs1
 1:10:2, 101:110:2, K=0,100,100, CS=cs1

*Constraint, Type=EarthSpring

Connects ground springs or dampers to a node.

*Constraint, Type=EarthSpring, Name=name
 targetNode, K=kx,ky,kz, C=cx,cy,cz, CS=cs
 targetNGroup, K=kx,ky,kz, C=cx,cy,cz, CS=cs
 ...
First data line and subsequent data lines
  • targetNode: Node for support boundary condition (required).
  • targetNGroup: Node group for support boundary condition(required). The targetNGroup can be specified as an nset, a surface, or a node number pattern (start:end:spacing, with spacing=1 being optional). If a surface is specified, it refers to all nodes that belong to that surface.
  • K=kx,ky,kz: Spring constants in each direction [F/L]. Default is 0.
  • C=cx,cy,cz: Damping coefficients in each direction [F*T/L]. Default is 0.
  • CS=cs: Coordinate system for the springs(*CoordinateSystem, TYPE=Orientation). If not specified, GCS is used.

Using *Constraint, TYPE=EarthSpring allows spring connections between nodes without the need for element IDs, unlike *Element, TYPE=EarthSpring. However, it only supports linear springs/dampers and does not provide rigid arms or allow calculation of internal forces in the springs/dampers.

The first entry in the data line searches for possible targets in the order of nset, surface, node number pattern, or node number. Note that predefined nset or surface names may consist of numbers, so caution is required.

Example
*Constraint, TYPE=EarthSpring, Name=connection1
 L1, K=0,100,100, C=0,20,30
 1:10, K=0,100,100

*CoordinateSystem, Type=Orientation, Name=cs1
  2,1,0
  3,0,1

*Constraint, TYPE=EarthSpring, Name=connection2
 bottomNodes, K=0,100,100, CS=cs1

*Constraint, Type=SpringBoundary

Springs or dampers distributed along the surface of elements, beam elements, or truss elements.

*Constraint, Type=SpringBoundary, Name=name
 surface|line, K=kx, ky, kz, C=cx, cy, cz, CS=GCS|ECS|cs
 ...
First data line and subsequent data lines
  • surface|line: Target surface or line made up of beam or truss elements.
  • K=kx,ky,kz: Distributed spring constants in each direction [F/L^2]. Default is 0.
  • C=cx,cy,cz: Distributed damping coefficients in each direction [F*T/L^2]. Default is 0.
  • CS=GCS|ECS|cs: Coordinate system to be used. GCS is the global coordinate system, ECS is the local coordinate system of the target surface or line element, and cs is a user-defined coordinate system specified by *Coordinate, TYPE=Orientation. Default is GCS.

SpringBoundary is used to model distributed springs or dampers on boundary surfaces. Unlike EarthSpring, which is used for individual springs/dampers, SpringBoundary can be easily applied to surfaces or lines composed of beam or truss elements. In 3D, spring constants and damping coefficients in all three directions are used, while in 2D, only kx, ky or cx, cy are applied. ECS refers to the local coordinate system for the surface or line, and GCS refers to the global coordinate system. You can also define a custom coordinate system using *CoordinateSystem, TYPE=Orientation.

Example
*Constraint, TYPE=SpringBoundary, Name=farBC1
 bottom, K=0,0,100
 wall, K=100,0,0, CS=ECS

*Constraint, Type=ViscousBoundary

Viscous boundary

*Constraint, Type=ViscousBoundary, Name=name
 surface, density, cp, cs
 surface
 ...
First data line and subsequent data lines
  • density, cp, cs: target surface, density [F*T2/L4], P-wave velocity (cp) [L/T], and S-wave velocity (cs) [L/T].
  • surface: The target surface. Density, cp, and cs are automatically calculated from the elements connected to the surface, which must be solid elements using IsoElasticity as their material property.

ViscousBoundary is used to model viscous boundaries applied to surfaces during dynamic analysis. Although damping can be specified with *Load, TYPE=DistributedSpring, this command allows for more convenient specification of density and velocity, or automatic calculation from the connected elements. The viscous boundary works in the surface's normal direction and applies damping coefficients per unit area. It operates in three directions (normal and two shear directions) for 3D solid element surfaces, and in the normal and shear directions for 2D or axisymmetric solid elements. ViscousBoundary can only be applied to surfaces composed of solid elements and cannot be applied to surfaces composed of shell elements or lines composed of beam or truss elements. It cannot be used redundantly on the same surface.

If density, cp, and cs are not directly provided, they will be calculated from the material properties of the elements forming the surface, which must use IsoElasticity.

Example
*Constraint, TYPE=ViscousBoundary, Name=farBC1
 side1
 side2

*Constraint, TYPE=ViscousBoundary, Name=farBC2
 side1                    # Calculating density, Vp, and Vs from the material model of the elements forming side1.
 side2, 1800, 300, 40      # Manually specifying density, cp, and cs.

*Constraint, Type=AcousticImpedance

Impedance boundary for acoustic elements.

*Constraint, Type=AcousticImpedance, Name=name
 surface, a, b
 ...
First data line and subsequent data lines
  • surface: The target surface.
  • a, b: impedance coefficients [a: T^2/L, b: T/L]

AcousticImpedance is used to apply impedance boundaries for acoustic elements when modeling fluid, such as sloshing conditions at free surfaces or radiation damping in an infinite domain. The surface must be defined as the outward normal of the acoustic region. In mathematically, this command represents

\[ \small \frac{\partial p}{\partial n} = -a\ddot{p} - b\dot{p} \]

This command is only available in *Step, TYPE=Dynamic and *Step, TYPE=Frequency. For more details, refer to the "Acoustic Solid Elements" section.

Example
*Constraint, TYPE=AcousticImpedance, Name=sloshing
 freeSurface, 1/9.81, 0   # surface, a, b

*Constraint, TYPE=AcousticImpedance, Name=farBC
 radiationBoundary, 0, 1.2/1480   # surface, a, b

Linkage between acoustic and solid elements.

*Constraint, Type=AcousticSolidLink, Name=name
 surface, density
 acousticSurface, solidSurface, density, radius, formulation
 ...
First data line and subsequent data lines
  • surface: The target surface.
  • acousticSurface, solidSurface: Shared surface between acoustic media and solid.
  • density: The density of the acoustic media [F*T2/L4].
  • radius: The effective radius for the normal vector from the acoustic surface nodes/material points to the solid surface [L]. A value of 0 indicates an infinite radius, meaning no radius is applied. Default is 0.
  • formulation: The method for handling unaligned mesh. Either UseConstraint or UseIntegration. UseConstraint generates normal direction DOFs at nodes of the acoustic surface, while UseIntegration increases the integration order. The default: UseConstraint.

AcousticSolidLink is used when considering the interaction between acoustic and solid elements, adding effects to both the mass and stiffness matrices. It also calculates external forces in cases such as earthquakes. This constraint is used for fluid-structure interaction analysis or to input seismic loads for fluids. It is only available in *Step, TYPE=Dynamic and *Step, TYPE=Frequency.

  • Aligned Mesh: For aligned meshes where the acoustic and solid surfaces are the same, use surface and density.
  • Unaligned Mesh: For unaligned meshes, use acousticSurface, solidSurface, density, radius, and formulation.
Example
*Constraint, TYPE=AcousticSolidLink, Name=acousticSolidLink
 damUpstream, 1000
 damBottom, 1000
 leftWater, tankRight, 1000
 water, tank, 1000, 5