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 objectvfe_MPCEnd()
- destroy an instance of a MPC objectvfe_MPCError()
- return MPC object error flag
Attributes and Parameters
vfe_MPCDef()
- specify constraint typevfe_MPCInq()
- inquire constraint typevfe_MPCSetParami()
- set integer parametersvfe_MPCSetParamd()
- set real parametersvfe_MPCSetDist()
- set ABAQUS distributed coupling propertiesvfe_MPCSetGround()
- set ground propertiesvfe_MPCSetJoint()
- set joint propertiesvfe_MPCSetKine()
- set kinematic coupling propertiesvfe_MPCSetLink()
- set inextensional coupling propertiesvfe_MPCSetPlane()
- set plane propertiesvfe_MPCSetPntSurf()
- set point on surface coupling propertiesvfe_MPCSetRBE3()
- set NASTRAN RBE3 propertiesvfe_MPCSetSlider()
- set slider coupling propertiesvfe_MPCSetStan()
- set standard MPC properties
Degree of Freedom Information
vfe_MPCDofMap()
- query element degree of freedom mapvfe_MPCNumDof()
- query number of element degrees of freedomvfe_MPCNumDepDof()
- query number of dependent degrees of freedomvfe_MPCDofPrimMap()
- query primary element degree of freedom mapvfe_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 vectorvfe_MPCReactStiff()
- reaction vector, stiffness matrixvfe_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 tovfe_MPCSetGround()
,MPC_PLANE
requires a call tovfe_MPCSetPlane()
,MPC_JOINT
requires a call tovfe_MPCSetJoint()
,MPC_KINE
requires a call tovfe_MPCSetKine()
,MPC_LINK
requires a call tovfe_MPCSetLink()
,MPC_PNTSURF
requires a call tovfe_MPCSetPntSurf()
,MPC_RBE3
requires a call tovfe_MPCSetRBE3()
,MPC_SLIDER
requires a call tovfe_MPCSetSlider()
,MPC_STAN
requires a call tovfe_MPCSetStan()
, andMPC_DIST
requires a call tovfe_MPCSetDist()
. By default type isMPC_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
andMPC_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 usingvfe_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 typeMPC_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 typeMPC_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 typeMPC_DIST_3D
is specified, ndistpnts must be at least 3 and the points may not be colinear. If typeMPC_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()
orvfe_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()
orvfe_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 defaultMPC_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 thatVFE_ANALYSIS_THERMAL
is only appropriate for aMPC_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 aMPC_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 thatVFE_ANALYSIS_THERMAL
is only appropriate for aMPC_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. IfVFE_LAGMULT_ONLY
is selected then the constraint is enforced only with a Lagrange multiplier. IfVFE_LAGMULT_AUGMENT
is selected then the constraint is enforced using a combination of Lagrange multiplier and penalty stiffness. By defaultVFE_LAGMULT
isVFE_LAGMULT_NONE
.Use
VFE_USEOFFSET
to toggle the inclusion of an offset in the point to surface coupling usingvfe_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 defaultVFE_USEOFFSET
isSYS_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 defaultVFE_SCALEPENALTY
isSYS_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