The methods associated with a ElemTran object are the following.
*vfe_ElemTranBegin - create an instance of a ElemTran object vfe_ElemTranEnd - destroy an instance of a ElemTran object vfe_ElemTranError - return ElemTran object error flag
vfe_ElemTranCondMap - query condensed degree of freedom map vfe_ElemTranCondMatrix - condense an element matrix vfe_ElemTranCondVector - condense an element vector vfe_ElemTranElimMatrix - eliminate freedoms from an element matrix vfe_ElemTranElimVector - eliminate freedoms from an element vector vfe_ElemTranSetCond - set degrees of freedom to be condensed vfe_ElemTranSetMap - set input element degree of freedom map vfe_ElemTranMatrix - transform an element matrix vfe_ElemTranUncondVector - expand (uncondense) an element vector vfe_ElemTranUnelimVector - expand an element vector vfe_ElemTranVector - transform an element vector
Transform selected nodal freedoms of an element vector using vfe_ElemTranVector. Transform selected nodal freedoms of an element matrix using vfe_ElemTranMatrix. The transformation matrices are given by a set of direction cosine matrices indicating the coordinate system to which nodal freedoms are to be transformed.
Selected degrees of freedom may be condensed from element matrices and vectors. The degrees of freedom to be condensed are set using vfe_ElemTranSetCond. By default, this is set to condense all internal element degrees of freedom. Use vfe_ElemTranCondVector and vfe_ElemTranCondMatrix to condense element vectors and matrices. Use the function vfe_ElemTranCondMap to query for the degree of freedom map which reflects the degree of freedom type and ordering for the condensed element vectors and matrices.
Destroy an instance of a ElemTran object using vfe_ElemTranEnd.
tm[0][0] = X'x tm[0][1] = X'y tm[0][2] = X'z
tm[1][0] = Y'x tm[1][1] = Y'y tm[1][2] = Y'z
tm[2][0] = Z'x tm[2][1] = Z'y tm[2][2] = Z'z
The process of element matrix condensation produces two associated recovery matrices which must be used as input to condense an associated element vector. In turn the process of element vector condensation produces an additional recovery vector which must be used along with the recovery matrices for uncondensing an element vector.
Assume that the uncondensed element matrix S is represented below in which the matrix has been partitioned into the retained freedoms followed by the condensed freedoms.
-- --
| A B |
S = | |
| B(T) C |
-- --
The condensed matrix, SCOND, is given by
SCOND = A - B(T) * C(-1) * BThe matrices B and C must be retained for performing any subsequent element vector condensations using the functions vfe_ElemTranCondVector and vfe_ElemTranUncondVector where they are referred to as the off diagonal recovery matrix bm and the block diagonal recovery matrix cm.
Assume that N is the number of degrees of freeom in the uncondensed matrix. This number is determined by the degree of freedom map specified using vfe_ElemTranSetMap. Assume that M is the number of degrees of freeom in the condensed matrix. This number may be queried using vfe_ElemTranCondMap. Let NC = N-M be the number of degrees of freedom which are condensed. The matrix B is stored column-wise and contains NC*M entries. The matrix C is stored in triangular format, already factorized:
C = L D L(T)with the diagonal entries of L equal to 1. C is returned in cm and contains NC*(NC+1)/2 entries. The exact data structures used for B and C are not exposed.
In some situations degrees of freedom do not need to be statically condensed but simply struck from the element vector or matrix. This process is performed using vfe_ElemTranElimVector and vfe_ElemTranElimMatrix. For example, if the internal degrees of freedom of an element stiffness matrix are condensed, the internal freedoms of the associated element mass matrix only need to be eliminated.
*vfe_ElemTranBegin - create an instance of a ElemTran object
vfe_ElemTran *vfe_ElemTranBegin ()
None
Destroy an instance of a ElemTran object using
void vfe_ElemTranEnd (vfe_ElemTran *elemtran )
Return the current value of a ElemTran object error flag using
Vint vfe_ElemTranError (vfe_ElemTran *elemtran )
vfe_ElemTranSetCond - set degrees of freedom to be condensed
void vfe_ElemTranSetCond (vfe_ElemTran *elemtran,
Vint nconds,
Vint loc[], Vint tag[])
elemtran Pointer to ElemTran object. nconds Number of element degrees of freedom to condense loc Vector of degree of freedom locations tag Vector of degree of freedom types
None
vfe_ElemTranSetMap - set current element degree of freedom map
void vfe_ElemTranSetMap (vfe_ElemTran *elemtran,
Vint nedofs,
Vint loc[], Vint tag[])
elemtran Pointer to ElemTran object. nedofs Number of element degrees of freedom loc Vector of degree of freedom locations tag Vector of degree of freedom types
None
vfe_ElemTranCondMap - query condensed degree of freedom map
void vfe_ElemTranCondMap (vfe_ElemTran *elemtran,
Vint *nedofs,
Vint loc[], Vint tag[])
elemtran Pointer to ElemTran object.
nedofs Number of element degrees of freedom in condensed element loc Vector of degree of freedom locations tag Vector of degree of freedom types
vfe_ElemTranCondMatrix - condense an element matrix
void vfe_ElemTranCondMatrix (vfe_ElemTran *elemtran,
Vdouble s[],
Vdouble scond[],
Vdouble bm[],
Vdouble cm[])
elemtran Pointer to ElemTran object. s Element matrix to condense.
scond Condensed element matrix bm Off diagonal recovery matrix cm Block Diagonal recovery matrix
vfe_ElemTranCondVector - condense an element vector
void vfe_ElemTranCondVector (vfe_ElemTran *elemtran,
Vdouble v[],
Vdouble bm[],
Vdouble cm[],
Vdouble vcond[],
Vdouble bv[])
elemtran Pointer to ElemTran object. v Element vector to condense. bm Off diagonal recovery matrix cm Block Diagonal recovery matrix
vcond Condensed element vector bv Recovery vector
vfe_ElemTranUncondVector - expand (uncondense) an element vector
void vfe_ElemTranUncondVector (vfe_ElemTran *elemtran,
Vdouble vcond[],
Vdouble bm[],
Vdouble cm[],
Vdouble bv[],
Vdouble v[])
elemtran Pointer to ElemTran object. vcond Element vector to uncondense. bm Off diagonal recovery matrix cm Block Diagonal recovery matrix bv Recovery vector
v Uncondensed element vector
vfe_ElemTranUnelimVector - expand an element vector
void vfe_ElemTranUelimVector (vfe_ElemTran *elemtran,
Vdouble ul[]
Vdouble vl[])
elemtran Pointer to ElemTran object. ul Array of degrees of freedom
vl Uneliminated degrees of freedom
NONE
vfe_ElemTranElimMatrix - eliminate freedoms from an element matrix
void vfe_ElemTranElimMatrix (vfe_ElemTran *elemtran,
Vdouble s[],
Vdouble selim[])
elemtran Pointer to ElemTran object. s Element matrix to eliminate.
selim Eliminated element matrix
vfe_ElemTranElimVector - eliminate freedoms from an element vector
void vfe_ElemTranElimVector (vfe_ElemTran *elemtran,
Vdouble v[],
Vdouble velim[])
elemtran Pointer to ElemTran object. v Element vector to eliminate.
velim Eliminated element vector
vfe_ElemTranMatrix - transform an element matrix
void vfe_ElemTranMatrix (vfe_ElemTran *elemtran,
Vint nin,
Vint in[],
Vdouble tm[][3][3],
Vdouble s[])
elemtran Pointer to ElemTran object.
nin Number of nodes to transform
in Vector of nin node indices to element connectivity
tm Array of nin direction cosine matrices indicating the
coordinate system to which nodal freedoms are to be
transformed
s Element matrix to transform.
None
vfe_ElemTranVector - transform an element vector
void vfe_ElemTranVector (vfe_ElemTran *elemtran,
Vint nin,
Vint in[],
Vdouble tm[][3][3],
Vdouble v[])
elemtran Pointer to ElemTran object.
nin Number of nodes to transform
in Vector of nin node indices to element connectivity
tm Array of nin direction cosine matrices indicating the
coordinate system to which nodal freedoms are to be
transformed
v Element vector to transform.
None
The methods associated with a NodeGeom object are the following.
*vfe_NodeGeomBegin - create an instance of a NodeGeom object vfe_NodeGeomEnd - destroy an instance of a NodeGeom object vfe_NodeGeomError - return NodeGeom object error flag
vfe_NodeGeomSetCenter - set center point vfe_NodeGeomSetMotion - set acceleration vfe_NodeGeomAcceleration - compute nodal acceleration vfe_NodeGeomForceMoment - sum force and moment about center vfe_NodeGeomFreeMode - compute unconstrained modes vfe_NodeGeomRigid - compute rigid body vector
Rigid body modes may be calculated using vfe_NodeGeomRigid. Forces and moments may be summed about the specified center point using vfe_NodeGeomForceMoment. The function vfe_NodeGeomFreeMode computes possible unconstrained motions or free modes given a set of translational and rotational constraints and their locations. This function is useful for determining if a set of user applied boundary conditions are sufficient to prevent rigid body motion and identify the rigid body motions if they exist.
Finertia = cx*fx + cy*fy + cz*fz + crx*frx + cry*fry + crz*frzCompute the total force and moment due to each rigid body mode about the center using vfe_NodeGeomForceMoment and set this equal to the corresponding component of the total force and moment due to the applied load. Fxx is total force in x of fx, etc. This yields the following set of 6 equations and 6 unknowns to be solved for the coefficients cx, cy, etc.
-- -- -- -- -- -- | Fextx | | Fxx 0 0 0 Fryx Frzx | | cx | | Fexty | | 0 Fyy 0 Frxy 0 Frzy | | cy | | Fextz | | 0 0 Fzz Frxz Fryz 0 | | cz | | Mextx | | 0 Myx Mzx Mxx 0 0 | | crx | | Mexty | | Mxy 0 Mzy 0 Myy 0 | | cry | | Mextz | | Mxz Myz 0 0 0 Mzz | | crz | -- -- -- -- -- --
*vfe_NodeGeomBegin - create an instance of a NodeGeom object
vfe_NodeGeom *vfe_NodeGeomBegin ()
None
Destroy an instance of a NodeGeom object using
void vfe_NodeGeomEnd (vfe_NodeGeom *nodegeom )
Return the current value of a NodeGeom object error flag using
Vint vfe_NodeGeomError (vfe_NodeGeom *nodegeom )
vfe_NodeGeomSetCenter - set center point
void vfe_NodeGeomSetCenter (vfe_NodeGeom *nodegeom,
Vdouble xc[3])
nodegeom Pointer to NodeGeom object. xc Coordinates of center point
None
vfe_NodeGeomSetMotion - specify acceleration
void vfe_NodeGeomSetMotion (vfe_NodeGeom *nodegeom,
Vdouble a[3],
Vdouble w[3],
Vdouble wdot[3])
nodegeom Pointer to NodeGeom object. a Translational acceleration vector w Angular velocity of rotating reference frame wdot Angular acceleration of rotating reference frame
None
vfe_NodeGeomAcceleration - compute nodal acceleration
void vfe_NodeGeomAcceleration (vfe_NodeGeom *nodegeom,
Vint npts,
Vdouble x[][3],
Vdouble a[][3])
nodegeom Pointer to NodeGeom object. npts Number of node coordinates x Node coordinates
a Acceleration vectors at nodes
vfe_NodeGeomForceMoment - sum force and moment about center
void vfe_NodeGeomForceMoment (vfe_NodeGeom *nodegeom,
Vdouble x[3],
Vint ntags,
Vint tag[],
Vdouble f[],
Vdouble force[3],
Vdouble moment[3])
nodegeom Pointer to NodeGeom object. x Node coordinates ntags Number of degrees of freedom types used at nodes tag Vector of degree of freedom types at nodes f Force and moment at node degrees of freedom
force Force vector moment Moment vector about center
vfe_NodeGeomFreeMode - compute unconstrained modes
void vfe_NodeGeomFreeMode (vfe_NodeGeom *nodegeom,
Vdouble x[][3],
Vint tmflag,
Vdouble tm[][3][3],
Vint ntags,
Vint loc[],
Vint tag[],
Vint *ntra,
Vdouble tra[3][3],
Vint *nrot,
Vdouble rot[3][6],
Vdouble off[3][3])
nodegeom Pointer to NodeGeom object. x Node coordinates tmflag Direction cosine matrices flag tm Node direction cosine matrices ntags Number of constrainted degrees of freedom loc Locations of constrained degrees of freedom tag Degree of freedom types of constraints
ntra Number of translational free modes tra Vector of translational free mode translations nrot Number of rotational free modes rot Vector of rotational free mode translations and rotations off Offset of axis of rotation from center
If the degrees of freedom are not applied in the global Cartesian coordinate system then the tmflag must be enabled and a direction cosine matrix ,tm, input for each unique node. If the tmflag is disabled, then tm may be input as NULL.
The number of translational, ntra, and rotational, nrot, rigid body modes are computed and returned. If there are translational rigid body modes, the translations associated with each mode are returned in tra. If there are rotational rigid body modes, the translations and rotations associated with each mode are returned in rot. The center point about which rotational rigid body modes are calculated is specified using vfe_NodeGeomSetCenter. The offset vector of a point relative to the center point through which the axis of rotation passes is returned in off. Note that the free modes are computed assuming the constraints are applied to a single continuous body.
vfe_NodeGeomRigid - compute rigid body vector
void vfe_NodeGeomRigid (vfe_NodeGeom *nodegeom,
Vint irigid,
Vdouble x[3],
Vint ntags,
Vint tag[],
Vdouble u[])
nodegeom Pointer to NodeGeom object.
irigid Rigid body vector to compute
=1 Translation in X
=2 Translation in Y
=3 Translation in Z
=4 Rotation about X
=5 Rotation about Y
=6 Rotation about Z
x Node coordinates
ntags Number of degrees of freedom types used at node
tag Vector of degree of freedom types at node
u Rigid body motion for degrees of freedom
The methods associated with a Corot object are the following.
*vfe_CorotBegin - create an instance of a Corot object vfe_CorotEnd - destroy an instance of a Corot object vfe_CorotError - return Corot object error flag
vfe_CorotDef - define dimensionality vfe_CorotPull - pull-back to reference coordinates vfe_CorotPush - push-forward to current coordinates vfe_CorotSetMap - set element degree of freedom map vfe_CorotSetParami - set corotational parameters vfe_CorotSetTopology - set element topology vfe_CorotUpdateRot - update rotational degree of freedoms
For each element there is, in general, a unique corotational frame which is attached to the element in its initial undeformed configuration and in its subsequent deformed configurations. At each iteration, use vfe_CorotPull to pull-back the array of displacements and rotations degrees of freedom to an equivalent infinitesimal value applicable to the element's initial reference configuration. vfe_CorotPull will overwrite the incoming degrees of freedom with the new, infinitesimal values.
Once element matrices and vectors are computed using the original, undeformed element coordinates - an important point, since anisotropy in the element is defined in the reference configuration - they must be pushed forward to the current configuration using vfe_CorotPush for assembly and solution, etc.
If the element formulation contains rotational degrees of freedom, there is an additional complication when large rotations are present. The update of the total displacement with the incremental displacement is not just a simple matter of addition when rotational degrees of freedom are present. This is due to the fact that the rotations are no longer, in general, infinitesimal. Use the function vfe_CorotUpdateRot to add the increments of rotational degrees of freedom to the total rotation degree of freedom vector.
The function vfe_CorotSetParami may be used to turn on and off the addition of the geometric "load" stiffness.
The user may want to toggle the calculation of the geometric load stiffness for nonlinear iteration convergence reasons. Disabling the geometric load stiffness term may provide a more stable but slower convergence rate.
/* declare objects */
vfe_Corot *corot;
Vint nedofs, loc[24], tag[24];
Vdouble x[4][3], u[24];
Vdouble r[24], k[24*(24+1)/2];
Vdouble tm[3][3];
Vdouble ur[3], urd[3], urp[3];
/* create corot object */
corot = vfe_CorotBegin ();
/* define dimensionality */
vfe_CorotDef (corot,VFE_3D);
/* specify element topology */
vfe_CorotSetTopology (corot,VIS_SHAPE_QUAD,2,0,0);
/* set degree of freedom map */
vfe_CorotSetMap (corot,nedofs,loc,tag);
/* at each load or time step */
...
/* pull-back displacements to reference configuration */
vfe_CorotPull (corot,x,u,tm);
/* form stiffness and force using modified u */
...
/* push reactions and stiffness to current configuration */
vfe_CorotPush (corot,SYS_ON,r,SYS_ON,k);
/* assemble forces, stiffnesses */
...
/* solve for increment of displacement */
...
/* for each rotation degree of freedom vector at a node */
/* update rotation pseudovector */
vfe_CorotUpdateRot (corot,ur,urd,urp);
/* go to next load or time step */
...
/* delete corot object */
vfe_CorotEnd (corot);
Table of Contents
*vfe_CorotBegin - create an instance of a Corot object
vfe_Corot *vfe_CorotBegin ()
None
Destroy an instance of a Corot object using
void vfe_CorotEnd (vfe_Corot *corot )
Return the current value of a Corot object error flag using
Vint vfe_CorotError (vfe_Corot *corot )
vfe_CorotDef - Define dimensionality
void vfe_CorotDef (vfe_Corot *corot,
Vint dim)
corot Pointer to Corot object.
dim Dimensionality
=VFE_2D Two-dimensional problem
=VFE_3D Three-dimensional problem
None
vfe_CorotPull - pull-back to reference coordinates
void vfe_CorotPull (vfe_Corot *corot,
Vdouble x[][3],
Vdouble u[],
Vdouble tm[3][3])
corot Pointer to Corot object. x Node coordinates in reference frame. u Current degree of freedom vector tm Direction cosine matrix from reference to corotational frame
u u is overwritten by its infinitesimal values
vfe_CorotPush - push-forward to current coordinates
void vfe_CorotPush (vfe_Corot *corot,
Vint rflag,
Vdouble r[],
Vint kflag,
Vdouble k[])
corot Pointer to Corot object. rflag Flag indicating whether reactions are to be pushed r Degree of freedom vector of reaction forces kflag Flag indicating whether stiffness matrix is to be pushed k Element stiffness matrix
r Reaction forces are replaced by their pushed values. k Element stiffness matrix is replaced by its pushed value.
vfe_CorotSetMap - set element degree of freedom map
void vfe_CorotSetMap (vfe_Corot *corot,
Vint nedofs,
Vint loc[], Vint tag[])
corot Pointer to Corot object. nedofs Number of element degrees of freedom loc Vector of degree of freedom locations tag Vector of degree of freedom types
None
vfe_CorotSetParami - set corotational parameters
void vfe_CorotSetParami (vfe_Corot *corot,
Vint type,
Vint iparam)
corot Pointer to Corot object.
type Type of parameter to set
=VFE_DIMENSION Model dimension
=VFE_GEOMSTIFF Enable geometric stiffness
iparam Integer parameter value.
=SYS_OFF Disable
=SYS_ON Enable
=2 or 3 Model dimension value
None
The addition of a geometric stiffness term to the element stiffness may be toggled using the VFE_GEOMSTIFF parameter. The geometric stiffness is added to the element stiffness in the function vfe_CorotPull and may be interpreted as a "load" stiffness. The addition of the geometric stiffness due to load may be disabled by setting VFE_GEOMSTIFF to SYS_OFF. By default VFE_GEOMSTIFF is set to SYS_OFF.
For two-dimensional problems, you must set VFE_DIMENSION to 2. This will enforce a local corotational system whereby the local z-direction is always aligned with the global z-direction. By default VFE_DIMENSION is set to 3.
vfe_CorotSetTopology - set element topology
void vfe_CorotSetTopology (vfe_Corot *corot,
Vint shape,
Vint maxi,
Vint maxj,
Vint maxk)
corot Pointer to Corot object.
shape The topological shape for the element
=VIS_SHAPELINE Line
=VIS_SHAPETRI Triangle
=VIS_SHAPEQUAD Quadrilateral
=VIS_SHAPETET Tetrahedron
=VIS_SHAPEWED Wedge
=VIS_SHAPEHEX Hexahedron
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 finite element is assumed.
If 2 <= maxj <= 3 and 2 <= maxi <= 3, then a Lagrange
finite element is assumed.
If maxi != 0 then maxj = 0 or maxj = maxi.
maxk The number of points along the k direction.
Currently maxk must be equal to maxj.
None
vfe_CorotUpdateRot - update rotational degree of freedoms
void vfe_CorotUpdateRot (vfe_Corot *corot,
Vdouble ur0[3],
Vdouble dur[3],
Vdouble ur[3])
corot Pointer to Corot object. ur0 Rotations at the end of the previous step dur Increment of rotations
ur Updated rotations