8. MultiPoint Constraints - MPC 

The MPC module provides the basic capability of modeling multipoint constraints. Multipoint constraints are a general way to relate degrees of freedom to one another within a model. They provide a very powerful tool which is useful for many modeling problems. An important example is transmitting load between nodes which are separated in space or are attached to different types of degrees of freedom such as translations and rotations.

The methods associated with a MPC object are the following.

Begin and end an instance of an object, generic object functions
- vfe_MPCBegin() - create an instance of a MPC object
- vfe_MPCEnd() - destroy an instance of a MPC object
- vfe_MPCError() - return MPC object error flag
Attributes and Parameters
- vfe_MPCDef() - specify constraint type
- vfe_MPCInq() - inquire constraint type
- vfe_MPCSetParami() - set integer parameters
- vfe_MPCSetParamd() - set real parameters
- vfe_MPCSetDist() - set ABAQUS distributed coupling properties
- vfe_MPCSetGround() - set ground properties
- vfe_MPCSetJoint() - set joint properties
- vfe_MPCSetKine() - set kinematic coupling properties
- vfe_MPCSetLink() - set inextensional coupling properties
- vfe_MPCSetPlane() - set plane properties
- vfe_MPCSetPntSurf() - set point on surface coupling properties
- vfe_MPCSetRBE3() - set NASTRAN RBE3 properties
- vfe_MPCSetSlider() - set slider coupling properties
- vfe_MPCSetStan() - set standard MPC properties
Degree of Freedom Information
- vfe_MPCDofMap() - query element degree of freedom map
- vfe_MPCNumDof() - query number of element degrees of freedom
- vfe_MPCNumDepDof() - query number of dependent degrees of freedom
- vfe_MPCDofPrimMap() - query primary element degree of freedom map
- vfe_MPCNumPrimDof() - query number of primary element degrees of freedom
Structural analysis computations
- vfe_MPCPrimReact() - constraint reaction vector.
- vfe_MPCPrimReactStiff() - constraint reaction vector, stiffness matrix.
- vfe_MPCPrimStiff() - constraint linear stiffness.
- vfe_MPCPrimCoeff() - primary constraint coefficients.
- vfe_MPCReact() - reaction vector
- vfe_MPCReactStiff() - reaction vector, stiffness matrix
- vfe_MPCStiff() - linear stiffness matrix
Transformations
- vfe_MPCSetDirCos() - set direction cosine matrices.

Instance a MPC object using vfe_MPCBegin(). Once a MPC object is instanced, define the multipoint constraint type using vfe_MPCDef(). Although the MPC module is designed for general multipoint constraints, it may be used effectively for the special case of single point constraints as well. Currently options exist for grounds, distributing couplings, interpolation constraints, NASTRAN like RBE1, RBE2, RBAR, RROD and RJOINT rigid body elements, and constraints oriented to a plane. The function vfe_MPCSetStan() is used to specify a “standard” or generic form for a multipoint constraint with an inhomogeneity.

Constraints may be imposed using either a penalty method or a direct transformation. If the penalty method is used then the penalty factor used to impose the constraint using a penalty function method is specified using vfe_MPCSetParamd(). The effective stiffness used to enforce the constraint and the force of constraint are computed using vfe_MPCStiff(), vfe_MPCReactStiff() and vfe_MPCReact().

By default, a penalty function method is used to impose the constraint. A Lagrange multiplier method may be chosen by calling vfe_MPCSetParami() with type VFE_LAGMULT. The Lagrange multiplier may be augmented by penalty stiffness if desired. If the Lagrange multiplier method is enabled, a Lagrange multiplier freedom type SYS_DOF_LAGM is added to the constraint degree of freedom map. This freedom type indicates an element local freedom type which must not be assembled to any other freedoms. The element “stiffness” matrix for a constraint satisfied with Lagrange multipliers will contain zeros on the diagonal. Care must be taken to process Lagrange multiplier freedoms when solving the global equation system to account for the zero diagonal entry at these freedoms. Usually this means that the global equation number for a Lagrange multiplier freedom must be after all other freedoms involved in its constraint equation. Also note that each Lagrange multiplier freedom will result in a negative root in the global system matrix. The coefficients of the Lagrange multiplier stiffness are scaled by the penalty factor.

Constraint calculations may be performed involving degrees of freedom in rotated coordinate systems. Use the function vfe_MPCSetDirCos() to set the direction cosine matrices for each degree of freedom location which is rotated. As a result of this feature, the stiffness matrix or transformation matrix representing the constraint will be expressed in the rotated degree of freedom system rather than the global coordinate system.

For cases where the MPC generates more than one constraint, it is more efficient to generate stiffness matrices and/or reaction forces one dependent degree of freedom at a time. The number of primary degrees of freedom for a specific dependent degree of freedom can be obtained with vfe_MPCNumPrimDof(), the the degree of freedom map is obtained with vfe_MPCDofPrimMap(). One then loops over each dependent degree of freedom and queries for reactions with vfe_MPCPrimReact(), linear stiffness with vfe_MPCPrimStiff(), or both with vfe_MPCPrimReactStiff().

Use vfe_MPCPrimCoeff() to retrieve the primary constraint coefficients for each dependent degree of freedom for use in a direct substitution approach.

8.1. Single Point Constraints

In many situations it is useful to be able to apply a single point constraint as a special case of a multipoint constraint. Direct constraint of a nodal degree of freedom, termed grounding, may be performed using vfe_MPCSetGround(). The constraint of nodal translations oriented to a plane may be performed using vfe_MPCSetPlane().

For example, a set of statically determinant constraints in 3D structural analysis may be applied by a combination of the following six single point constraints on three node locations, a, b and c, which define a plane. Three translations are grounded at node a, normal translations are constrained at nodes b and c and a tangential translation is constrained at node b.

8.2. Inextensional and Sliding Couplings

An inextensional coupling provides a simple pinned rigid connection between two nodes. The coupling preserves the distance between the two nodes. Only the translational degrees of freedom of the nodes are involved in the constraint. The inextensional coupling provides a constraint similar to the NASTRAN RROD rigid body element and the ABAQUS MPC LINK. Use vfe_MPCSetLink() to define inextensional couplings.

The sliding coupling restrains a node to be on a line connecting two other nodes. The node may slide along the line and the line is free to change length. The sliding coupling is similar to the ABAQUS MPC SLIDER Use vfe_MPCSetSlider() to define sliding couplings.

8.3. Rigid Joints

Rigid joints are a simple way of matching a list of degrees of freedom between two nodes. Use vfe_MPCSetJoint() to define the list of degrees of freedom to be matched.

8.4. Kinematic Couplings

Kinematic couplings provide a general tying of the translations and rotations of a node or set of nodes to the translations and rotations of another set of nodes. There are always exactly 6 independent degrees of freedom which must be capable of representing any general rigid body motion of the coupling nodes. This coupling is capable of modeling NASTRAN RBE1, RBE2 and RBAR rigid body elements and ABAQUS KINEMATIC COUPLING constraints. Use vfe_MPCSetKine() to define kinematic couplings. Thermal expansion coefficient definition for kinematic couplings elements is also supported. Use vfe_MPCSetKineWithThermalExpansion() to define kinematic couplings with thermal expansion.

8.5. Distributing Couplings

A distributing coupling provides a constraint to distribute force and moment at a point to forces at a set of coupling nodes. The coupling effectively constrains the rotation and translation at a point to the translations at the set of coupling nodes. This constraint is enforced in an average sense and therefore does not inhibit the relative deformation of the coupling nodes. In this respect it provides a more flexible constraint compared to a set of rigid links. There are two forms of the constraint. One that is like the NASTRAN RBE3 interpolation constraint element and the other like the ABAQUS DCOUP2D and DCOUP3D distributing coupling elements.

Two forms of the ABAQUS distributed coupling constraint are implemented, one for 3D analysis and another specifically useful for 2D analysis. The ABAQUS distributed coupling type is specified using vfe_MPCSetDist(). The NASTRAN RBE3 interpolation constraint type is specified using vfe_MPCSetRBE3().

A closely related constraint is the point on surface constraint implemented with vfe_MPCSetPntSurf(). This constraint couples the translations and rotations of a node to the translations of the nodes on an element face.

8.6. Standard Form

Multipoint constraints in standard form are a series of n terms of the form:

C1*U1 + C2*U2 + ... + Ci*Ui + ... + Cn*Un = R

where Ui represents a degree of freedom at a node and Ci is the associated coefficient. The multipoint constraint may be contain an inhomogeneity, R. The first degree of freedom, U1, is defined to be the dependent freedom. This implies that C1 must not be zero. The standard form type is specified using vfe_MPCSetStan().

8.7. Function Descriptions

The currently available MPC functions are described in detail in this section.

vfe_MPC *vfe_MPCBegin(void)

create an instance of a MPC object

Create an instance of a MPC object. Memory is allocated for the object private data and the pointer to the object is returned.

Destroy an instance of a MPC object using

void vfe_MPCEnd (vfe_MPC *mpc)

Return the current value of a MPC object error flag using

Vint vfe_MPCError (vfe_MPC *mpc)

Returns:: The function returns a pointer to the newly created MPC object. If the object creation fails, NULL is returned.

void vfe_MPCEnd(vfe_MPC *p)

destroy an instance of a MPC object

See vfe_MPCBegin()

Vint vfe_MPCError(vfe_MPC *p)

return the current value of a MPC object error flag

See vfe_MPCBegin()

void vfe_MPCDef(vfe_MPC *p, Vint type)

specify constraint type

Define the type of constraint to be specified. MPC_GROUND requires a call to vfe_MPCSetGround(), MPC_PLANE requires a call to vfe_MPCSetPlane(), MPC_JOINT requires a call to vfe_MPCSetJoint(), MPC_KINE requires a call to vfe_MPCSetKine(), MPC_LINK requires a call to vfe_MPCSetLink(), MPC_PNTSURF requires a call to vfe_MPCSetPntSurf(), MPC_RBE3 requires a call to vfe_MPCSetRBE3(), MPC_SLIDER requires a call to vfe_MPCSetSlider(), MPC_STAN requires a call to vfe_MPCSetStan(), and MPC_DIST requires a call to vfe_MPCSetDist(). By default type is MPC_STAN.

Inquire of a defined type as an output argument using

void vfe_MPCInq (vfe_MPC *mpc,
                 Vint *type)

Errors: SYS_ERROR_ENUM is generated if an improper type is specified.

Parameters:

p – Pointer to MPC object.

type – Constraint type

x=MPC_DIST                  ABAQUS Distributed coupling
 =MPC_GROUND                Ground
 =MPC_PLANE                 Plane
 =MPC_JOINT                 Rigid joint
 =MPC_KINE                  Kinematic coupling
 =MPC_LINK                  Inextensional coupling
 =MPC_PNTSURF               Point to surface
 =MPC_RBE3                  NASTRAN RBE3
 =MPC_SLIDER                Slider coupling
 =MPC_STAN                  Standard form

void vfe_MPCInq(vfe_MPC *p, Vint *type)

inquire of a defined type as an output argument

See vfe_MPCDef()

void vfe_MPCSetJoint(vfe_MPC *p, Vint ntag, Vint tags[])

set joint type constraint

Define the list of degrees of freedom to be matched between two nodes. The degree of freedom tag may only be a translational or rotational degree of freedom, ie.

SYS_DOF_TX
SYS_DOF_TY
SYS_DOF_TZ
SYS_DOF_RX
SYS_DOF_RY
SYS_DOF_RZ

Errors: SYS_ERROR_ENUM is generated if an improper tag is specified.

Parameters:

p – Pointer to MPC object.
ntag – Number of degrees of freedom to match
tags – List of degrees of freedom to match

void vfe_MPCSetGround(vfe_MPC *p, Vint tag)

set ground type constraint

Define the type of degree of freedom to be grounded at a node. This is equivalent to a single point constraint of the specified freedom. The degree of freedom tag may only be a translational or rotational degree of freedom, ie.

SYS_DOF_TX
SYS_DOF_TY
SYS_DOF_TZ
SYS_DOF_RX
SYS_DOF_RY
SYS_DOF_RZ

Errors: SYS_ERROR_ENUM is generated if an improper tag is specified.

Parameters:

p – Pointer to MPC object.
tag – Degree of freedom at node

void vfe_MPCSetStan(vfe_MPC *p, Vint nterms, Vint tag[], Vdouble c[], Vdouble r)

set standard MPC properties

Define a multipoint constraint in standard form. The series contains nterms. Each term is defined by an entry in the tag and c arrays. The degree of freedom associated with the first term is defined to be the dependent degree of freedom.

Errors

SYS_ERROR_ENUM is generated if an improper tag is specified.
SYS_ERROR_VALUE is generated if an improper nterms or loc is specified.

Parameters:

p – Pointer to MPC object.
nterms – Number of terms in standard form
tag – Types of nterms degrees of freedom
c – Coefficients
r – Inhomogeneity

void vfe_MPCSetPlane(vfe_MPC *p, Vint type)

set plane type properties

The 3D plane type constraints, MPC_PLANE_NORM3D and MPC_PLANE_TANG3D, define a directional constraint specified by three nodes which define a plane. The three node locations must not be co-linear. Although the plane is defined by three node locations the constraint is only applied to translational degrees of freedom located at the first node, the subsequent two node locations are used to define the plane geometry and no stiffness coefficents are generated for them. The directions of the degrees of freedom at the first node location may be specified using vfe_MPCSetDirCos().

The 2D plane type constraint, MPC_PLANE_TANG2D, is meant for 2D analysis and defines a directional constraint specified by two nodes which define a line.

The constraint type MPC_PLANE_NORM3D constrains the displacement at the first node normal to the plane. The constraint type MPC_PLANE_TANG3D constrains the displacement at the first node tangent to the plane and normal to the line between the first and second node. The constraint type MPC_PLANE_TANG2D constrains the displacement at the first node tangent to the line between the first and second node.

Errors: SYS_ERROR_ENUM is generated if an improper type is specified.

Parameters:

p – Pointer to MPC object.

type – Type of plane oriented constraint

x=MPC_PLANE_NORM3D        Constraint normal to plane
 =MPC_PLANE_TANG3D        Constraint tangential to plane
 =MPC_PLANE_TANG2D        Constraint tangential to line

void vfe_MPCSetDist(vfe_MPC *p, Vint type, Vint ndistpnts, Vint wflag, Vdouble w[])

set distributed coupling type constraint

Define a distributed coupling constraint which constrains the dependent translations and rotations of a point to the independent motion of the translational degrees of freedom at a set of ndistpnts points.

The constraint is intended to be used to distribute forces and moments from a point to forces at a set of coupling nodes. In the special cases in which the coupling nodes are co-linear a rotation stabilization option is available.

This constraint does not impose rigid body constraints on the coupling nodes. The coupling nodes are free to deform and as such this makes this constraint more flexible in comparison to a set of rigid link constraints. A vector of user supplied weights, w, for each of the ndistpnts coupling nodes may be supplied by setting the flag, wflag. If wflag is zero then w is ignored and a set of equal weights is used internally. In this case w may be entered as NULL. Internally all user input weights are scaled to sum to unity.

If type MPC_DIST_2D is specified, ndistpnts must be at least 2 and the points may not be coincident. If type MPC_DIST_3D is specified, ndistpnts must be at least 3 and the points may not be colinear. If type MPC_DIST_3DROT is specified, ndistpnts must be at least 2 and the points may be colinear. This constraint must only be used when rotational degrees of freedom are active at the independent coupling nodes, ie. are connected to shell or beam type elements.

This constraint utilizes ndistpnts + 1 coordinates, the first being the dependent node containing the force to be distributed and the subsequent coordinates being the coupling nodes.

The directions of the degrees of freedom at the degree of freedom locations may be specified using vfe_MPCSetDirCos().

Errors

SYS_ERROR_ENUM is generated if an improper type is specified.
SYS_ERROR_VALUE is generated if an improper ndistpnts is specified.
SYS_ERROR_VALUE is generated if non positive w are specified.

Parameters:

p – Pointer to MPC object.

type – Type of distributed coupling

x=MPC_DIST_2D            2D distributed coupling
 =MPC_DIST_3D            3D distributed coupling
 =MPC_DIST_3DROT         3D distributed stabilized coupling

ndistpnts – Number of coupling points to which load is distributed.

wflag – User supplied weights flag

x=SYS_OFF                No weights provided
 =SYS_ON                 Weights provided

w – Vector of user supplied weights at coupling nodes

void vfe_MPCSetRBE3(vfe_MPC *p, Vint ndepdof, Vint tagsdep[], Vint ndistdofs, Vint indeplocs[], Vint indeptags[], Vint wflag, Vdouble w[])

set NASTRAN RBE3 properties

Define a NASTRAN RBE3 interpolation constraint which constrains the dependent ndepdofs translations and/or rotations of a point to the motion of a set of ndistdofs degrees of freedom. The number of coordinates involved in the constraint are 1 plus the number of unique locations specified in indeplocs. The dependent degrees of freedom are assumed to be the first coordinate location, all indeplocs values must be greater than or equal to 2.

A vector of user supplied weights, w, for each of the ndistdofs interpolation degrees of freedom may be supplied by setting the flag, wflag. If wflag is zero then w is ignored and a set of equal weights is used internally. In this case w may be entered as NULL.

The directions of the degrees of freedom at the degree of freedom locations may be specified using vfe_MPCSetDirCos().

Errors

SYS_ERROR_VALUE is generated if an improper ndepdof is specified.
SYS_ERROR_VALUE is generated if an improper ndistdofs is specified.
SYS_ERROR_VALUE is generated if non positive w are specified.

Parameters:

p – Pointer to MPC object.
ndepdof – Number of dependent degrees of freedom 1 <= ndepdof <= 6
tagsdep – Types of ndepdof dependent degrees of freedom
ndistdofs – Number of independent interpolation degrees of freedom
indeplocs – Locations of ndistdofs interpolation degrees of freedom
indeptags – Types of ndistdofs degrees of freedom

wflag – User supplied weights flag

x=SYS_OFF                No weights provided
 =SYS_ON                 Weights provided

w – Vector of ndistdofs user supplied weights

void vfe_MPCSetKineWithThermalExpansion(vfe_MPC *p, Vint loc[], Vint tag[], Vint ntagdep, Vint locdep[], Vint tagdep[], Vdouble alpha)

set kinematic coupling type properties

The kinematic constraint defines a rigid body connected to an arbitrary number of points and can be used to generate constraints equivalent to the NASTRAN RBE1, RBE2 and RBAR rigid body elements. These rigid body element types may be decomposed into a series of individual constraints - one for each location of a set of dependent degrees of freedom. Call this function to establish the prototype degree of freedom relationship between the independent set of freedoms and the dependent degrees of freedom at a specific location. Then call the desired function vfe_MPCStiff() or vfe_MPCReact() with the two appropriate independent and dependent locations. Repeat this for each dependent point location. The locations and types of degrees of freedom specified must be capable of representing any general rigid body motion.

The directions of the degrees of freedom at the degree of freedom locations may be specified using vfe_MPCSetDirCos().

Errors

SYS_ERROR_ENUM is generated if an improper tag or tagdep is specified.
SYS_ERROR_VALUE is generated if an improper loc, ntagdep or locdep is specified.

Parameters:

p – Pointer to MPC object.
loc – Locations of 6 independent degrees of freedom
tag – Types of 6 independent degrees of freedom
ntagdep – Number of degrees of freedom at dependent location
locdep – Locations of ntagdep dependent degrees of freedom
tagdep – Types of ntagdep dependent degrees of freedom
alpha – Thermal expansion coefficient

void vfe_MPCSetKine(vfe_MPC *p, Vint loc[6], Vint tag[6], Vint ntagdep, Vint locdep[], Vint tagdep[])

set kinematic coupling type properties

The kinematic constraint defines a rigid body connected to an arbitrary number of points and can be used to generate constraints equivalent to the NASTRAN RBE1, RBE2 and RBAR rigid body elements. These rigid body element types may be decomposed into a series of individual constraints - one for each location of a set of dependent degrees of freedom. Call this function to establish the prototype degree of freedom relationship between the independent set of freedoms and the dependent degrees of freedom at a specific location. Then call the desired function vfe_MPCStiff() or vfe_MPCReact() with the two appropriate independent and dependent locations. Repeat this for each dependent point location. The locations and types of degrees of freedom specified must be capable of representing any general rigid body motion.

The directions of the degrees of freedom at the degree of freedom locations may be specified using vfe_MPCSetDirCos().

Errors

SYS_ERROR_ENUM is generated if an improper tag or tagdep is specified.
SYS_ERROR_VALUE is generated if an improper loc, ntagdep or locdep is specified.

Parameters:

p – Pointer to MPC object.
loc – Locations of 6 independent degrees of freedom
tag – Types of 6 independent degrees of freedom
ntagdep – Number of degrees of freedom at dependent location
locdep – Locations of ntagdep dependent degrees of freedom
tagdep – Types of ntagdep dependent degrees of freedom

void vfe_MPCSetLink(vfe_MPC *p, Vint locdep, Vint tagdep)

set inextensional coupling type properties

The inextensional constraint defines a rigid link connected to two points and can be used to generate constraints equivalent to the NASTRAN RROD rigid body element. The constraint generates a constraint equation in which the tagdep degree of freedom at location locdep is constrained to the motion of the translational degrees of freedom of the other location. The directions of the degrees of freedom at the two locations may be specified using vfe_MPCSetDirCos().

Errors

SYS_ERROR_ENUM is generated if an improper tagdep is specified.
SYS_ERROR_VALUE is generated if an improper locdep is specified.

Parameters:

p – Pointer to MPC object.
locdep – Location of dependent degree of freedom
tagdep – Type of dependent degree of freedom

void vfe_MPCSetPntSurf(vfe_MPC *p, Vint shape, Vint maxi, Vint maxj)

set point on surface coupling type properties

The point on surface constraint couples the translations and rotations of a dependent node to the translations of the nodes on an element face. The offset of the dependent node from its projection onto the surface may or may not be included depending upon the parameter VFE_USEOFFSET set using vfe_MPCSetParami(). The dependent node is the first node in the constraint connectivity followed by the nodes on the element face.

The directions of the degrees of freedom at the degree of freedom locations may be specified using vfe_MPCSetDirCos().

Errors

SYS_ERROR_VALUE is generated if an improper maxi or maxj is specified.
SYS_ERROR_ENUM is generated if an improper shape is input.

Parameters:

p – Pointer to MPC object.

shape – The topological shape for the surface

x=SYS_SHAPETRI           Triangle
 =SYS_SHAPEQUAD          Quadrilateral

maxi – The number of points along the i direction. If maxi = 0 then the linear Serendipity element form of the specified shape is assumed.
maxj – The number of points along the j direction. If maxj = 0 then a Serendipity element surface is assumed. If 2 <= maxj <= 3 and 2 <= maxi <= 3, then a Lagrange element surface is assumed. If maxi != 0 then maxj = 0 or maxj = maxi.

void vfe_MPCSetSlider(vfe_MPC *p, Vint tagdep[], Vint offsetflag)

set slider coupling type properties

The slider constraint defines a sliding coupling of a dependent node along a line between two other nodes. The node may slide along the line and the line is free to change length. The dependent node is the first node in the constraint connectivity. Only translational freedoms are involved in the constraint. The direction of the two dependent freedoms must project on the plane perpendicular to the line between the two nodes.

The directions of the degrees of freedom at the degree of freedom locations may be specified using vfe_MPCSetDirCos().

Errors: SYS_ERROR_ENUM is generated if an improper tagdep is specified.

Parameters:

p – Pointer to MPC object.
tagdep – Type of three dependent degrees of freedom
offsetflag – Value of the slider offset

void vfe_MPCSetParamd(vfe_MPC *p, Vint type, Vdouble dparam)

set real parameters

Set double precision parameters. Use MPC_PENALTY to set the penalty factor used to enforce the multipoint constraint with the penalty function method. By default MPC_PENALTY is set to 1.e+10.

Errors

SYS_ERROR_ENUM is generated if an improper type is specified.
SYS_ERROR_VALUE is generated if an improper dparam is specified.

Parameters:

p – Pointer to MPC object.

type – Type of formulation parameter to set

x=MPC_PENALTY            Penalty used to enforce constraint

dparam – Double parameter value.

void vfe_MPCNumDof(vfe_MPC *p, Vint analysistype, Vint *nedofs)

query number of element degrees of freedom

Query for number of element degree of freedom nedofs. The number of degrees of freedom will be the sum of the independent and dependent degrees of freedom. If Lagrange multipliers are used to satisfy the constraint then an additional Lagrange multiplier freedom will result. Use vfe_MPCDofMap() to return the location and type of each degree of freedom. Note that VFE_ANALYSIS_THERMAL is only appropriate for a MPC_STAN type constraint.

Errors: SYS_ERROR_ENUM is generated if an improper analysistype is specified.

Parameters:

p – Pointer to MPC object.

analysistype – The type of analysis

x=VFE_ANALYSIS_STRUCTURAL Structural analysis
 =VFE_ANALYSIS_THERMAL    Thermal analysis

nedofs – [out] Number of element degrees of freedom

void vfe_MPCNumDepDof(vfe_MPC *p, Vint analysistype, Vint *ndepdofs)

query number of dependent degrees of freedom

Query for number of dependent degrees of freedom, ndepdofs. Note that VFE_ANALYSIS_THERMAL is only appropriate for a MPC_STAN type constraint.

Errors: SYS_ERROR_ENUM is generated if an improper analysistype is specified.

Parameters:

p – Pointer to MPC object.

analysistype – The type of analysis

x=VFE_ANALYSIS_STRUCTURAL Structural analysis
 =VFE_ANALYSIS_THERMAL    Thermal analysis

ndepdofs – [out] Number of element dependent degrees of freedom

void vfe_MPCNumPrimDof(vfe_MPC *p, Vint *nprimdofs)

query number of primary degrees of freedom

Query for number of primary degrees of freedom, nprimdofs.

Parameters:

p – Pointer to MPC object.
nprimdofs – [out] Number of primary degrees of freedom

void vfe_MPCDofMap(vfe_MPC *p, Vint analysistype, Vint loc[], Vint tag[])

query element degree of freedom map

Query for element degree of freedom map. The degree of freedom map consists of a location index, loc and type, tag for each degree of freedom used by the element.

The length of the loc and tag vectors is equal to the number of element degrees of freedom. Use vfe_MPCNumDof() to return the number of element degrees of freedom. Note that VFE_ANALYSIS_THERMAL is only appropriate for a MPC_STAN type constraint.

Errors: SYS_ERROR_ENUM is generated if an improper analysistype is specified.

Parameters:

p – Pointer to MPC object.

analysistype – The type of analysis

x=VFE_ANALYSIS_STRUCTURAL Structural analysis
 =VFE_ANALYSIS_THERMAL    Thermal analysis

loc – [out] Vector of degree of freedom locations
tag – [out] Vector of degree of freedom types

void vfe_MPCDofPrimMap(vfe_MPC *p, Vint id, Vint loc[], Vint tag[])

query primary element degree of freedom map

Query for primary degree of freedom map. The degree of freedom map consists of a location index, loc and type, tag for each independent degree of freedom used by the element. A different map and location must be obtained for each primary constraint given by its id, 1 <= id <= ndepdofs

The length of the loc and tag vectors is equal to the number of element primary degrees of freedom. Use vfe_MPCNumPrimDof() to return the number of primary element degrees of freedom.

Parameters:

p – Pointer to MPC object.
id – Dependent degree of freedom id
loc – [out] Vector of degree of freedom locations
tag – [out] Vector of degree of freedom types

void vfe_MPCPrimCoeff(vfe_MPC *p, Vint iddof, Vdouble x[][3], Vdouble bm[], Vdouble *c)

standard constraint coefficients for a dependent dof

Compute the standard coefficients bm and the non-homogeneous term c given the node coordinates, x, for a specific dependent degree of freedom iddof.

Parameters:

p – Pointer to MPC object.
iddof – Dependent degree of freedom
x – Array of node locations.
bm – [out] Coefficients of standard constraint
c – [out] Non-homogeneous coefficient for standard constraint

void vfe_MPCReactStiff(vfe_MPC *p, Vdouble x[][3], Vdouble u[], Vint kflag, Vdouble r[], Vdouble k[])

reaction vector, stiffness matrix

Compute the linear stiffness matrix, kl, given the node coordinates, x. The lower triangle of the stiffness matrix is returned.

Parameters:

p – Pointer to MPC object.
x – Array of node locations.
u – Degree of freedom vector of displacements

kflag – Flag to compute stiffness matrix, k

=SYS_OFF      Do not compute stiffness matrix
=SYS_ON       Compute and return stiffness matrix

r – [out] Degree of freedom reaction vector
k – [out] Degree of freedom stiffness matrix

void vfe_MPCPrimReactStiff(vfe_MPC *p, Vdouble x[][3], Vdouble u[], Vint iddof, Vint kflag, Vdouble r[], Vdouble k[])

reaction vector, stiffness matrix for a dependent dof

Compute the reaction vector, r, and optionally the stiffness matrix, k, given the node coordinates, x, and the degree of freedom displacement vector, u, for a specific dependent degree of freedom iddof. The lower triangle of the stiffness matrix is returned.

Parameters:

p – Pointer to MPC object.
x – Array of node locations.
u – Degree of freedom vector of displacements
iddof – Dependent degree of freedom

kflag – Flag to compute stiffness matrix, k

=SYS_OFF      Do not compute stiffness matrix
=SYS_ON       Compute and return stiffness matrix

r – [out] Degree of freedom reaction vector
k – [out] Degree of freedom stiffness matrix

void vfe_MPCReact(vfe_MPC *p, Vdouble x[][3], Vdouble u[], Vdouble r[])

reaction vector

Compute the reaction vector, r, given the node coordinates, x, and the degree of freedom displacement vector, u.

Parameters:

p – Pointer to MPC object.
x – Array of node locations.
u – Degree of freedom vector of displacements
r – [out] Degree of freedom reaction vector

void vfe_MPCPrimReact(vfe_MPC *p, Vdouble x[][3], Vdouble u[], Vint iddof, Vdouble r[])

reaction vector for a dependent dof

Compute the reaction vector, r, given the node coordinates, x, and the degree of freedom displacement vector, u, for a specific dependent degree of freedom iddof.

Parameters:

p – Pointer to MPC object.
x – Array of node locations.
u – Degree of freedom vector of displacements
iddof – Dependent degree of freedom
r – [out] Degree of freedom reaction vector

void vfe_MPCPrimStiff(vfe_MPC *p, Vdouble x[][3], Vint iddof, Vdouble kl[])

linear stiffness matrix for a dependent dof

Compute the linear stiffness matrix, kl, given the node coordinates, x, for a specific dependent degree of freedom iddof. The lower triangle of the stiffness matrix is returned.

Parameters:

p – Pointer to MPC object.
x – Array of node locations.
iddof – Dependent degree of freedom
kl – [out] Degree of freedom stiffness matrix

void vfe_MPCSetParami(vfe_MPC *p, Vint type, Vint iparam)

set integer parameters

Set integer parameters. Use VFE_LAGMULT to specify the use of Lagrange multiplier freedoms and penalty stiffness to enforce the multipoint constraint. If VFE_LAGMULT_ONLY is selected then the constraint is enforced only with a Lagrange multiplier. If VFE_LAGMULT_AUGMENT is selected then the constraint is enforced using a combination of Lagrange multiplier and penalty stiffness. By default VFE_LAGMULT is VFE_LAGMULT_NONE.

Use VFE_USEOFFSET to toggle the inclusion of an offset in the point to surface coupling using vfe_MPCSetPntSurf(). If disabled then the constraint is generated assuming the dependent node location has been projected to the surface. If enabled an additional offset constraint is added to the point on surface constraint to account for the offset of the dependent node from its projection point on the surface. By default VFE_USEOFFSET is SYS_OFF.

Use VFE_SCALEPENALTY to toggle the scaling of the penalty factor so that the maximum diagonal on the stiffness matrix is equal to the penalty. If disabled, the penalty is not scaled and magnitude of the stiffness terms will be generally dependent upon the coordinate units. By default VFE_SCALEPENALTY is SYS_OFF.

Errors

SYS_ERROR_ENUM is generated if an improper type is specified.
SYS_ERROR_VALUE is generated if an improper iparam is specified.

Parameters:

p – Pointer to MPC object.

type – Type of formulation parameter to set

x=VFE_LAGMULT            Lagrange multiplier
 =VFE_USEOFFSET          Toggle inclusion of point to surface
                         coupling offset.
 =VFE_SCALEPENALTY       Scale penalty to normalize constraints

iparam – Integer parameter value.

x=SYS_OFF                Toggle off
 =SYS_ON                 Toggle on
 =VFE_LAGMULT_NONE       Lagrange multiplier off, penalty only
 =VFE_LAGMULT_ONLY       Lagrange multiplier only
 =VFE_LAGMULT_AUGMENT    Lagrange multiplier and penalty

void vfe_MPCSetDirCos(vfe_MPC *p, Vint nlocs, Vint locs[], Vdouble rot[][3][3])

set direction cosine matrices.

Sets direction cosine matrices for each location that requires one. When appropriate, the constraint is applied in the local direction.

Parameters:

p – Pointer to MPC object.
nlocs – Number of location points
locs – Location points
rot – [out] nlocs direction cosine matrices

void vfe_MPCSetPropPtr(vfe_MPC *p, Vint type, Vdouble *propptr)

set pointer to element nodal properties

Set a pointer to the start of a specified type of element properties. Note that the properties are not copied by this function, only the pointer itself is copied. If a property pointer is not set the element assumes a default value for the associated property. By default the temperature is 0. and reference temperature is 0.

Errors: SYS_ERROR_ENUM is generated if an improper type is specified.

Parameters:

p – Pointer to Solid3d object.

type – Type of element property

x=VFE_PROP_TEMPERATURE      Temperatures
 =VFE_PROP_TEMPREF          Reference temperatures

propptr – Pointer to start of element nodal properties

8. MultiPoint Constraints - MPC

8.1. Single Point Constraints

8.2. Inextensional and Sliding Couplings

8.3. Rigid Joints

8.4. Kinematic Couplings

8.5. Distributing Couplings

8.6. Standard Form

8.7. Function Descriptions

8. MultiPoint Constraints - MPC 