13. Examples

This chapter contains example VfeTools programs. The source code for all examples resides in devtools/src/vfe/exam.

13.1. Example 1, Generate Stiffness, Mass and Loads for a 3D 10 Node Tetrahedron

This example illustrates forming the stiffness matrix, consistent and diagonal mass matrices and the load vectors for two distributed loads for a 3D 10 node tetrahedron. Three objects are required; a LinMat object to hold the material properties, a Solid3D object to form the element stiffness, mass, etc. and a MatlFun object to provide the interface between the element formulation, Solid3D, and the underlying material model, LinMat.

The material properties are isotropic linear elastic and characteristic of aluminum. A LinMat object is instanced and defined to contain an isotropic material. The Young’s modulus, Poisson’s ratio and density of the material are set. A MatlFun object is instanced and filled with the interface to the LinMat object using vfe_LinMatMatlFun(). A Solid3D element formulation object is instanced and configured to generate element matrices and vectors for isoparametric parabolic Serendipity tetrahedra (10 nodes). The MatlFun object is registered with Solid3D using vfe_Solid3DSetObject(). This completes the connection between the element formulation and the material model. Element quantities such as stiffness, mass, etc. can now be computed.

The element stiffness matrix is generated using vfe_Solid3DStiff() The lower triangle of the matrix is returned in array kl. All isoparametric element formulations supported by Solid3D use 3 translations per node. The total number of degrees of freedom for the 10 node tetrahedron is 30. The output arrays for matrices and vectors have been dimensioned exactly to accommodate the output for this element. Both the consistent and diagonal mass matrices are generated.

Two varieties of distributed loads are computed; a constant pressure and a variable force per unit area directed along the global x axis. Each load is applied to face 3 of the tetrahedron. Note that the function vfe_Solid3DDistLoad() which is used to compute consistent nodal loads, requires the element node coordinate array, x, and element node load magnitudes, v, even though only the nodes on face 3 will be referenced. The output load vector, f, contains the computed consistent loads for each element degree of freedom.

#include <stdio.h>
#include "base/base.h"
#include "vfe/vfe.h"

static Vdouble x[10][3] = {
  {0.,0.,0.}, {2.,0.,0.}, {0.,2.,0.}, {0.,0.,2.},
  {1.,0.,0.}, {1.,1.,0.}, {0.,1.,0.},
  {0.,0.,1.}, {1.,0.,1.}, {0.,1.,1.} };

/*----------------------------------------------------------------------
                      Generate Stiffness Matrix for 10 Node Tetrahedron
----------------------------------------------------------------------*/
int
main()
{
   Vint i, j;
   Vdouble prop[2];
   Vdouble kl[465];
   Vdouble mc[465], md[30];
   Vdouble v[10], f[30];
   vfe_Solid3D *solid3d;
   vfe_MatlFun *matlfun;
   vfe_LinMat  *linmat;

                   /* Create material object and set properties */ 
   linmat  = vfe_LinMatBegin ();
   vfe_LinMatDef (linmat,SYS_MAT_ISOTROPIC);
   prop[0] = 10000000.;
   prop[1] = .3;
   vfe_LinMatSetElasProp (linmat,prop);
   vfe_LinMatSetDensity (linmat,.0000133);

                   /* Create MatlFun object and load material functions */ 
   matlfun = vfe_MatlFunBegin ();
   vfe_LinMatMatlFun (linmat, matlfun);

                   /* Create 3D solid element formulation */ 
   solid3d = vfe_Solid3DBegin ();
   vfe_Solid3DSetParami (solid3d,VFE_TECH,VFE_TECH_ISOP);
   vfe_Solid3DSetTopology (solid3d,SYS_SHAPETET,3,0,0);

                   /* Register material functions */ 
   vfe_Solid3DSetObject (solid3d,VFE_MATLFUN,matlfun);

                   /* Form stiffness matrix */ 
   vfe_Solid3DStiff (solid3d,x,kl);

                   /* Form consistent mass matrix */ 
   vfe_Solid3DMass (solid3d,x,mc);

                   /* Form diagonal mass matrix */ 
   vfe_Solid3DMassDiag (solid3d,x,md);

   printf("Diagonal mass matrix\n");
   for(i = 0; i < 10; i++) {
      for(j = 0; j < 3; j++) {
         printf("%12.4e ",md[3*i+j]);
      }
      printf("\n");
   }

                   /* Form load vector for constant pressure */ 
   for(i = 0; i < 10; i++)  v[i] = 1.;
   vfe_Solid3DDistLoad (solid3d,x,SYS_FACE,3,VFE_DISTLOAD_PRES,v,f);

   printf("Constant pressure load vector\n");
   for(i = 0; i < 10; i++) {
      for(j = 0; j < 3; j++) {
         printf("%12.4e ",f[3*i+j]);
      }
      printf("\n");
   }

                   /* Delete objects */ 
   vfe_Solid3DEnd (solid3d);
   vfe_MatlFunEnd (matlfun);
   vfe_LinMatEnd  (linmat);
   return 0;
}

13.2. Example 1a, Query for Element Degrees of Freedom

This example uses the 10 node tetrahedron introduced in Example 1 and illustrates the procedure for querying for the number and type of degrees of freedom, called the dof “map”, used by the element.

#include <stdlib.h>
#include <stdio.h>
#include "base/base.h"
#include "vfe/vfe.h"

static Vdouble x[10][3] = {
  {0.,0.,0.}, {2.,0.,0.}, {0.,2.,0.}, {0.,0.,2.},
  {1.,0.,0.}, {1.,1.,0.}, {0.,1.,0.},
  {0.,0.,1.}, {1.,0.,1.}, {0.,1.,1.} };

/*----------------------------------------------------------------------
                      Query for Degree of Freedom Map for 10 Node Tetrahedron
----------------------------------------------------------------------*/
int
main()
{
   Vint i;
   Vdouble prop[2];
   Vdouble *kl;
   Vint nedofs;
   Vint loc[VFE_MAXDOF], tag[VFE_MAXDOF];
   vfe_Solid3D *solid3d;
   vfe_MatlFun *matlfun;
   vfe_LinMat  *linmat;

                   /* Create material object and set properties */ 
   linmat  = vfe_LinMatBegin ();
   vfe_LinMatDef (linmat,SYS_MAT_ISOTROPIC);
   prop[0] = 10000000.;
   prop[1] = .3;
   vfe_LinMatSetElasProp (linmat,prop);
   vfe_LinMatSetDensity (linmat,.0000133);

                   /* Create MatlFun object and load material functions */ 
   matlfun = vfe_MatlFunBegin ();
   vfe_LinMatMatlFun (linmat, matlfun);

                   /* Create 3D solid element formulation */ 
   solid3d = vfe_Solid3DBegin ();
   vfe_Solid3DSetParami (solid3d,VFE_TECH,VFE_TECH_ISOP);
   vfe_Solid3DSetTopology (solid3d,SYS_SHAPETET,3,0,0);

                   /* Register material functions */ 
   vfe_Solid3DSetObject (solid3d,VFE_MATLFUN,matlfun);

                   /* Query for element degree of freedom map */
   vfe_Solid3DNumDof (solid3d,VFE_ANALYSIS_STRUCTURAL,&nedofs);
   vfe_Solid3DDofMap (solid3d,VFE_ANALYSIS_STRUCTURAL,loc,tag);
                   /* Set tag names */ 
   printf("Degree of freedom map\n");
   for(i = 0; i < nedofs; i++) {
     if(tag[i]==SYS_DOF_TX) printf("loc[%2d]= %2d, tag[%2d]= TX\n",i,loc[i],i);
     if(tag[i]==SYS_DOF_TY) printf("loc[%2d]= %2d, tag[%2d]= TY\n",i,loc[i],i);
     if(tag[i]==SYS_DOF_TZ) printf("loc[%2d]= %2d, tag[%2d]= TZ\n",i,loc[i],i);
   }

                   /* Allocate storage for element stiffness */ 
   kl = (Vdouble*) malloc(sizeof(Vdouble)*(nedofs*(nedofs+1)/2));

                   /* Form stiffness matrix */ 
   vfe_Solid3DStiff (solid3d,x,kl);

                   /* Free allocated storage for element stiffness */ 
   free(kl);
                   /* Delete objects */ 
   vfe_Solid3DEnd (solid3d);
   vfe_MatlFunEnd (matlfun);
   vfe_LinMatEnd  (linmat);
   return 0;
}

13.3. Example 2, Generate Stiffness, Loads for a 2D Plane Stress Cantilever Beam

This example illustrates generating the stiffness and loads for a 2D plane stress cantilever beam consisting of 10 6 node triangles.

#include <stdio.h>
#include <stdlib.h>
#include "base/base.h"
#include "vfe/vfe.h"

static void
gat_vector(Vdouble x[][3], Vint np, Vint con[4], Vdouble xe[][3]);
static void
set_scalar(Vdouble s, Vint np, Vdouble se[]);

static Vint is[2][6] = {
   { 1, 7, 9, 4, 8, 5 },
   { 9, 3, 1, 6, 2, 5 } };

/*----------------------------------------------------------------------
                      2D Plane Stress Cantilever
----------------------------------------------------------------------*/
int
main()
{
   Vint i, j, k;
   Vdouble prop[2];
   Vdouble x[33][3];
   Vint ix[10][6];
   Vdouble xe[6][3], te[6];
   Vint nelems;
   Vint nedofs;
   Vdouble *kl;
   vfe_Solid2D *solid2d;
   vfe_MatlFun *matlfun;
   vfe_LinMat  *linmat;

                   /* Generate 3 by 11 mesh of nodes */
   k = 0;
   for(j = 0; j < 11; j++) {
      for(i = 0; i < 3; i++) {
         x[k][0] = .2 * j;
         x[k][1] = .1 * i;
         x[k][2] = 0.;
         k++;
      }
   }
                   /* set number of elements */ 
   nelems = 10;
                   /* Generate 10 triangular elements */
   k = 0;
   for(j = 0; j < nelems; j += 2) {
      for(i = 0; i < 6; i++) {
         ix[j][i]   = k+is[0][i];
         ix[j+1][i] = k+is[1][i];
      }
      k += 6;
   }
                   /* Create material object and set properties */ 
   linmat  = vfe_LinMatBegin ();
   vfe_LinMatDef (linmat,SYS_MAT_ISOTROPIC);
   prop[0] = 10000000.;
   prop[1] = .3;
   vfe_LinMatSetElasProp (linmat,prop);
   vfe_LinMatSetDensity (linmat,.000254);

                   /* Create MatlFun object and load material functions */ 
   matlfun = vfe_MatlFunBegin ();
   vfe_LinMatMatlFun (linmat, matlfun);

                   /* Create 2D solid element formulation */ 
   solid2d = vfe_Solid2DBegin ();
   vfe_Solid2DSetParami (solid2d,VFE_TECH,VFE_TECH_ISOP);
   vfe_Solid2DSetTopology (solid2d,SYS_SHAPETRI,3,0);

                   /* Register material functions */ 
   vfe_Solid2DSetObject (solid2d,VFE_MATLFUN,matlfun);

                   /* Determine number of degrees of freedom */ 
   vfe_Solid2DNumDof (solid2d,VFE_ANALYSIS_STRUCTURAL,&nedofs);

                   /* Allocate memory for element stiffnesses */ 
   kl = (Vdouble*) malloc(sizeof(Vdouble)*(nedofs*(nedofs+1)/2));

                   /* Form stiffness matrix element by element */ 
   vfe_Solid2DSetPropPtr (solid2d,VFE_PROP_DEPTH,te);
   for(i = 0; i < nelems; i++) {
      set_scalar (.5,6,te);
      gat_vector (x,6,ix[i],xe);
      vfe_Solid2DStiff (solid2d,xe,kl);
                   /* print first and last element */ 
      if(i == 0  ||  i == nelems-1) {
         printf("Lower triangle of stiffness matrix\n");
         for(k = 0; k < nedofs; k++) {
            for(j = 0; j <= k; j++) {
               printf("%12.4e ",kl[k*(k+1)/2+j]);
            }
            printf("\n");
         }
      }
   }
                   /* Free memory */ 
   free(kl);
                   /* Delete objects */ 
   vfe_Solid2DEnd (solid2d);
   vfe_MatlFunEnd (matlfun);
   vfe_LinMatEnd (linmat);
   return 0;
}

/*----------------------------------------------------------------------
                      Utility function to gather element vectors
----------------------------------------------------------------------*/
static void
gat_vector(Vdouble x[][3], Vint np, Vint con[4], Vdouble xe[][3])
{
   int i;

   for(i = 0; i < np; i++) {
      xe[i][0] = x[con[i]-1][0];
      xe[i][1] = x[con[i]-1][1];
      xe[i][2] = x[con[i]-1][2];
   }
}

/*----------------------------------------------------------------------
                      Utility function to set element scalars
----------------------------------------------------------------------*/
static void
set_scalar(Vdouble s, Vint np, Vdouble se[])
{
   int i;

   for(i = 0; i < np; i++) {
      se[i] = s;
   }
}
../../_images/vfetools-exam2.gif

Figure 9-1, 2D Plane Stress Cantilever Beam Mesh

13.4. Example 3, Generate Stiffness, Mass and Loads for a 3D 4 Node Shell

This example illustrates forming the stiffness matrix, consistent and diagonal mass matrices and the load vector for a pressure load for a 3D 4 node quadrilateral shell element. Five objects are required; a LinMat object to hold the material properties, a ShellProp object to hold information related to the element properties. a Shell3D object to form the element stiffness, mass, etc. and two MatlFun objects to provide the interfaces between the element formulation, Shell3D, the element properties, ShellProp,and the underlying material model, LinMat.

As in Example 1, the material properties are isotropic linear elastic and characteristic of aluminum. A LinMat object is instanced and defined to contain an isotropic material. The Young’s modulus, Poisson’s ratio and density of the material are set. A MatlFun object is instanced and filled with the interface to the LinMat object using vfe_LinMatMatlFun(). At this point this example departs from Example 1 in that a ShellProp object must be used to specify the shell wall (through the shell thickness) construction. In this case a monocoque (single layer) shell wall is specified using vfe_ShellPropDef() and vfe_ShellPropSetMonocoque(). For linear material properties it is only necessary to use 2 point Gaussian quadrature to integrate through the shell thickness. A monocoque shell wall may only consist of a single material which is specified to be material 1. The MatlFun object associated with the linear material properties is registered with ShellProp as material 1 using vfe_ShellPropSetMatlFun(). An additional MatlFun object will now be required to connect the ShellProp object to the Shell3D element formulation object. Therefore another MatlFun object is instanced and filled with the interface to the ShellProp object using vfe_ShellPropMatlFun().

A Shell3D element formulation object is instanced and configured to generate element matrices and vectors for linear quadrilateral shells (4 nodes) using an assumed natural strain technology. A preintegrated formulation (using moments and curvatures) is chosen.

The MatlFun object, matlfunprop, is registered with Shell3D using vfe_Shell3DSetObject(). This completes the connections between the element formulation, the element properties and the material model. The total thickness at each element node is set to .1 and is entered into the array th. The pointer to this array is registered with the Shell3D object using vfe_Shell3DSetPropPtr(). Any other element nodal properties such as offsets or shell normals would be specified in a similar manner. Element quantities such as stiffness, mass, etc. can now be computed.

The element stiffness matrix is generated using vfe_Shell3DStiff() The lower triangle of the matrix is returned in array kl. All element formulations supported by Shell3D use 3 translations and 3 rotations per node. The total number of degrees of freedom for the 4 node quadrilateral shell is 24. The output arrays for matrices and vectors have been dimensioned exactly to accommodate the output for this element. Both the consistent and diagonal mass matrices are generated. A constant pressure load is computed using vfe_Shell3DDistLoad().

#include <stdio.h>
#include "base/base.h"
#include "vfe/vfe.h"

static Vdouble x[4][3] = {
  {0.,0.,0.}, {1.,0.,0.}, {1.,1.,0.}, {0.,1.,0.} };

/*----------------------------------------------------------------------
                      Generate Stiffness Matrix for 4 Node Quadrilateral Shell
----------------------------------------------------------------------*/
int
main()
{
   Vint i, j, k;
   Vdouble prop[2];
   Vdouble sprop[2];
   Vdouble kl[300];
   Vdouble mc[300], md[24];
   Vdouble v[4], f[24];
   vfe_Shell3D *shell3d;
   vfe_MatlFun *matlfun;
   vfe_LinMat  *linmat;
   vfe_MatlFun   *matlfunprop;
   vfe_ShellProp *shellprop;

                   /* Create material object and set properties */ 
   linmat  = vfe_LinMatBegin ();
   vfe_LinMatDef (linmat,SYS_MAT_ISOTROPIC);
   prop[0] = 10000000.;
   prop[1] = .3;
   vfe_LinMatSetElasProp (linmat,prop);
   vfe_LinMatSetDensity (linmat,.0000133);

                   /* Create MatlFun object and load material functions */ 
   matlfun = vfe_MatlFunBegin ();
   vfe_LinMatMatlFun (linmat, matlfun);

                   /* Create shell property object */ 
   shellprop = vfe_ShellPropBegin ();
   vfe_ShellPropDef (shellprop,SHELLPROP_MONOCOQUE);
   sprop[0] = .1;
   sprop[1] = 5./6.;
   vfe_ShellPropSetMonocoque (shellprop,sprop,2,SYS_RULE_GAUSS,0.,1);
   vfe_ShellPropSetMatlFun (shellprop,1,matlfun);

                   /* Create MatlFun object and load shell property functions */
   matlfunprop = vfe_MatlFunBegin ();
   vfe_ShellPropMatlFun (shellprop,matlfunprop);

                   /* Create 3D shell element formulation */ 
   shell3d = vfe_Shell3DBegin ();
   vfe_Shell3DSetParami (shell3d,VFE_TECH,VFE_TECH_ANS);
   vfe_Shell3DSetParami (shell3d,VFE_ROTINERTIA,SYS_ON);
   vfe_Shell3DSetTopology (shell3d,SYS_SHAPEQUAD,2,0);

                   /* Register material functions */ 
   vfe_Shell3DSetObject (shell3d,VFE_MATLFUN,matlfunprop);

                   /* Form stiffness matrix */ 
   vfe_Shell3DStiff (shell3d,x,kl);

   printf("Diagonal of stiffness matrix\n");
   for(i = 0; i < 4; i++) {
      for(j = 0; j < 6; j++) {
         k = 6*i+j+1;
         printf("%12.4e ",kl[k*(k+1)/2-1]);
      }
      printf("\n");
   }

                   /* Form consistent mass matrix */ 
   vfe_Shell3DMass (shell3d,x,mc);

                   /* Form diagonal mass matrix */ 
   vfe_Shell3DMassDiag (shell3d,x,md);

   printf("Diagonal mass matrix\n");
   for(i = 0; i < 4; i++) {
      for(j = 0; j < 6; j++) {
         printf("%12.4e ",md[6*i+j]);
      }
      printf("\n");
   }

                   /* Form load vector for constant pressure */ 
   for(i = 0; i < 4; i++)  v[i] = 1.;
   vfe_Shell3DDistLoad (shell3d,x,SYS_FACE,0,VFE_DISTLOAD_PRES,v,f);

   printf("Constant pressure load vector\n");
   for(i = 0; i < 4; i++) {
      for(j = 0; j < 6; j++) {
         printf("%12.4e ",f[6*i+j]);
      }
      printf("\n");
   }

                   /* Delete objects */ 
   vfe_Shell3DEnd (shell3d);
   vfe_MatlFunEnd (matlfun);
   vfe_LinMatEnd  (linmat);
   vfe_MatlFunEnd   (matlfunprop);
   vfe_ShellPropEnd (shellprop);
   return 0;
}

13.5. Example 3a, Using a Custom MatlFun Object with Example 3

This example illustrates using a custom MatlFun (material functions) object to interface a user defined material model to an element formulation. This is a modification of Example 3 in which the material model for a 4 node quadrilateral shell element was implemented using the ShellProp and LinMat material models. The custom material model is designed to reproduce exactly the material model used in Example 3, so that the computed stiffness and mass matrices are identical.

Only a single MatlFun object is required. All material functions are registered using vfe_MatlFunSet(). Note that the material functions registered in the MatlFun object provide for a user specified pointer (object) to be passed as the first argument. In this example the pointer argument is used to pass the element thickness, effective shear factor and material modulii so that the shell wall matrix can be computed.

#include <stdio.h>
#include "base/base.h"
#include "vfe/vfe.h"

static Vdouble x[4][3] = {
  {0.,0.,0.}, {1.,0.,0.}, {1.,1.,0.}, {0.,1.,0.} };

typedef struct {
   Vdouble t;             /* thickness */
   Vdouble shearfactor;   /* shear factor */
   Vdouble E;             /* Young's modulus */
   Vdouble nu;            /* Poisson's ratio */
   Vdouble rho;           /* density */
} MaterialProperties;

                   /* function to compute shell wall matrix */ 
static void
exam_DConstruct(Vobject *obj, Vdouble dmatrix[8][8])
{
   MaterialProperties *mat = (MaterialProperties*)obj;
   Vdouble tmp1,tmp2,tmp3,tmp4,tmp5,tmp6,tmp7;
   Vdouble E           = mat->E;
   Vdouble t           = mat->t;
   Vdouble nu          = mat->nu;
   Vdouble shearfactor = mat->shearfactor;
   Vint    i,j;

   tmp1 = E*t*t*t/(12.*(1.-nu*nu));
   tmp2 = nu*tmp1;
   tmp3 = 0.5*(1-nu)*tmp1;
   tmp4 = E*t/(1.-nu*nu);
   tmp5 = nu*tmp4;
   tmp6 = 0.5*(1.-nu)*tmp4;
   tmp7 = shearfactor*E*t/(2.*(1+nu));

   for(i = 0; i < 8; ++i) {
      for(j = 0; j < 8; ++j) {
         dmatrix[i][j] = 0.;
      }
   }

   dmatrix[0][0] = tmp4;
   dmatrix[0][1] = tmp5;
   dmatrix[1][0] = tmp5;
   dmatrix[1][1] = tmp4;
   dmatrix[2][2] = tmp6;
   dmatrix[3][3] = tmp1;
   dmatrix[3][4] = tmp2;
   dmatrix[4][3] = tmp2;
   dmatrix[4][4] = tmp1;
   dmatrix[5][5] = tmp3;
   dmatrix[6][6] = tmp7;
   dmatrix[7][7] = tmp7;
}

/*----------------------------------------------------------------------
                      Material functions for laminate description
----------------------------------------------------------------------*/
static void
exam_DCond(Vobject *obj, Vint cond[])
{
                   /* cond contains all zeros for 3D preintegrated shell */
}

static void
exam_DInfo(Vobject *obj, Vint type, Vint *info)
{
   if(type == VFE_MATLELEM) {
      *info = SYS_ELEM_SHELL;
   } else if(type == VFE_MATLFULL) {
      *info = SYS_OFF;
   } else if(type == VFE_STRAINTYPE) {
      *info = VFE_SMALLSTRAIN;
   }
}

static void
exam_DMatrix(Vobject *obj, Vdouble dm[])
{
   Vint i,j,k;
   Vdouble dmatrix[8][8];

   exam_DConstruct (obj,dmatrix);

   k = 0;
   for(i = 0; i < 8; i++) {
      for(j = 0; j <= i; j++) {
         dm[k++] = dmatrix[i][j];
      }
   }
}

static void
exam_Stress(Vobject *obj, Vdouble dfrm[], Vdouble strs[])
{
   Vint i, j;
   Vdouble dmatrix[8][8];

   exam_DConstruct (obj,dmatrix);
   for(i = 0; i < 8; i++) {
      strs[i] = 0.;
      for(j = 0; j < 8; j++) {
         strs[i] += dmatrix[i][j] * dfrm[j];
      }
   }
}

static void
exam_StressDMatrix(Vobject *obj, 
                   Vdouble dfrm[], Vint dflag, Vdouble strs[], Vdouble dm[])
{
   exam_Stress (obj,dfrm,strs);
                   /* assume DMatrix is not a function of deformation */ 
   if(dflag) {
      exam_DMatrix (obj,dm);
   }
}

static void
exam_Modulus(Vobject *obj, Vdouble *modulus)
{
   MaterialProperties *mat = (MaterialProperties*)obj;
   Vdouble t           = mat->t;
   Vdouble dmatrix[8][8];

   exam_DConstruct (obj,dmatrix);
   *modulus = dmatrix[0][0]*t*t/12.;
}

static void
exam_Density(Vobject *obj, Vdouble density[])
{
   MaterialProperties *mat = (MaterialProperties*)obj;
   Vdouble t   = mat->t;
   Vdouble rho = mat->rho;

   density[0] = rho*t;
   density[1] = 0.;
   density[2] = rho*t*t*t/12.;
}

static void
exam_Prop(Vobject *obj, Vint ptype, Vdouble prop)
{
                   /* only called if vfe_Shell3DSetPropPtr is called */ 
}

static void
exam_NumHist(Vobject *obj, Vint *numhist)
{
   *numhist = 0;
}

static void
exam_ElemIntPnt(Vobject *obj,
                Vint elemintpnt, Vdouble r[3], Vdouble w, Vdouble dj)
{
                   /* use this function to compute any user defined results */ 
}

static void
exam_NumStressStrain(Vobject *obj, Vint *num)
{
                   /* use this function to compute layered stress and strain */ 
   *num = 0;
}

/*----------------------------------------------------------------------
                      Generate Stiffness Matrix for 4 Node Quadrilateral Shell
----------------------------------------------------------------------*/
int
main()
{
   Vint i, j, k;
   Vdouble kl[300];
   Vdouble mc[300], md[24];
   Vdouble v[4], f[24];
   vfe_Shell3D *shell3d;
   vfe_MatlFun *mf;
   MaterialProperties mat;

                   /* shell and material properties */ 
   mat.t           = 0.1;
   mat.shearfactor = 5./6.;
   mat.E           = 1.e+7;
   mat.nu          = 0.3;
   mat.rho         = 0.0000133;

                   /* Create MatlFun object and load material functions */ 
   mf = vfe_MatlFunBegin ();
   vfe_MatlFunSet (mf,MATLFUN_DCOND          ,(void(*)(void))exam_DCond);
   vfe_MatlFunSet (mf,MATLFUN_DINFO          ,(void(*)(void))exam_DInfo);
   vfe_MatlFunSet (mf,MATLFUN_DMATRIX        ,(void(*)(void))exam_DMatrix);
   vfe_MatlFunSet (mf,MATLFUN_STRESS         ,(void(*)(void))exam_Stress);
   vfe_MatlFunSet (mf,MATLFUN_STRESSDMATRIX  ,(void(*)(void))exam_StressDMatrix);
   vfe_MatlFunSet (mf,MATLFUN_MODULUS        ,(void(*)(void))exam_Modulus);
   vfe_MatlFunSet (mf,MATLFUN_DENSITY        ,(void(*)(void))exam_Density);
   vfe_MatlFunSet (mf,MATLFUN_PROP           ,(void(*)(void))exam_Prop);
   vfe_MatlFunSet (mf,MATLFUN_NUMHIST        ,(void(*)(void))exam_NumHist);
   vfe_MatlFunSet (mf,MATLFUN_ELEMINTPNT     ,(void(*)(void))exam_ElemIntPnt);
   vfe_MatlFunSet (mf,MATLFUN_NUMSTRESSSTRAIN,(void(*)(void))exam_NumStressStrain);
   vfe_MatlFunSetObj(mf,(Vobject*)&mat);

                   /* Create 3D shell element formulation */ 
   shell3d = vfe_Shell3DBegin ();
   vfe_Shell3DSetParami (shell3d,VFE_TECH,VFE_TECH_ANS);
   vfe_Shell3DSetParami (shell3d,VFE_ROTINERTIA,SYS_ON);
   vfe_Shell3DSetTopology (shell3d,SYS_SHAPEQUAD,2,0);

                   /* Register material functions */ 
   vfe_Shell3DSetObject (shell3d,VFE_MATLFUN,mf);

                   /* Form stiffness matrix */ 
   vfe_Shell3DStiff (shell3d,x,kl);

   printf("Diagonal of stiffness matrix\n");
   for(i = 0; i < 4; i++) {
      for(j = 0; j < 6; j++) {
         k = 6*i+j+1;
         printf("%12.4e ",kl[k*(k+1)/2-1]);
      }
      printf("\n");
   }

                   /* Form consistent mass matrix */ 
   vfe_Shell3DMass (shell3d,x,mc);

                   /* Form diagonal mass matrix */ 
   vfe_Shell3DMassDiag (shell3d,x,md);

   printf("Diagonal mass matrix\n");
   for(i = 0; i < 4; i++) {
      for(j = 0; j < 6; j++) {
         printf("%12.4e ",md[6*i+j]);
      }
      printf("\n");
   }

                   /* Form load vector for constant pressure */ 
   for(i = 0; i < 4; i++)  v[i] = 1.;
   vfe_Shell3DDistLoad (shell3d,x,SYS_FACE,0,VFE_DISTLOAD_PRES,v,f);

   printf("Constant pressure load vector\n");
   for(i = 0; i < 4; i++) {
      for(j = 0; j < 6; j++) {
         printf("%12.4e ",f[6*i+j]);
      }
      printf("\n");
   }

                   /* Delete objects */ 
   vfe_Shell3DEnd (shell3d);
   vfe_MatlFunEnd (mf);
   return 0;
}

13.6. Example 4, Generate Stiffness, Mass and Loads for a 3D 3 Node Beam

This example illustrates forming the stiffness matrix, consistent and diagonal mass matrices and the load vector for a line load for a 3D 3 node beam element. Five objects are required; a LinMat object to hold the material properties, a BeamProp object to hold information related to the element properties. a Beam3D object to form the element stiffness, mass, etc. and two MatlFun objects to provide the interfaces between the element formulation, Beam3D, the element properties, BeamProp,and the underlying material model, LinMat.

The procedure for defining the element properties and material properties is similar to Example 3 for shell elements. A BeamProp object must be used to specify the beam section construction. In this case the BeamProp object is configured to manage general section area properties using vfe_BeamPropDef() and vfe_BeamPropSetSection(). A beam section may only consist of a single material which is specified to be material 1. The MatlFun object associated with the linear material properties is registered with BeamProp as material 1 using vfe_BeamPropSetMatlFun(). An additional MatlFun object will now be required to connect the BeamProp object to the Beam3D element formulation object. Therefore another MatlFun object is instanced and filled with the interface to the BeamProp object using vfe_BeamPropMatlFun().

A Beam3D element formulation object is instanced and configured to generate element matrices and vectors for parabolic beams (3 nodes) using an isoparametric technology. A preintegrated formulation (using moments and curvatures) is chosen.

The MatlFun object, matlfunprop, is registered with Beam3D using vfe_Beam3DSetObject(). This completes the connections between the element formulation, the element properties and the material model. The area properties for a constant 1. by .2 rectangular beam section are specified at the element nodes. The area, moments of inertia about the y and z section axes and the torsional constant are set using vfe_Beam3DSetPropPtr() Any other element nodal properties such as offsets or beam node normals would be specified in a similar manner. Element quantities such as stiffness, mass, etc. can now be computed.

The element stiffness matrix is generated using vfe_Beam3DStiff() The lower triangle of the matrix is returned in array kl. All element formulations supported by Beam3D use 3 translations and 3 rotations per node. The total number of degrees of freedom for the 3 node beam is 18. The output arrays for matrices and vectors have been dimensioned exactly to accommodate the output for this element. Both the consistent and diagonal mass matrices are generated. A constant line load is computed using vfe_Beam3DDistLoad().

#include <stdio.h>
#include "base/base.h"
#include "vfe/vfe.h"

static Vdouble x[4][3] = {
  {0.,0.,0.}, {1.,0.,0.}, {2.,0.,0.} };

/*----------------------------------------------------------------------
                      Generate Stiffness Matrix for 3 Node Beam
----------------------------------------------------------------------*/
int
main()
{
   Vint i, j, k;
   Vdouble prop[2];
   Vdouble bprop[10];
   Vdouble kl[171];
   Vdouble mc[171], md[18];
   Vdouble v[3][3], f[18];
   vfe_Beam3D *beam3d;
   vfe_MatlFun *matlfun;
   vfe_LinMat  *linmat;
   vfe_MatlFun  *matlfunprop;
   vfe_BeamProp *beamprop;

                   /* Create material object and set properties */ 
   linmat  = vfe_LinMatBegin ();
   vfe_LinMatDef (linmat,SYS_MAT_ISOTROPIC);
   prop[0] = 10000000.;
   prop[1] = .3;
   vfe_LinMatSetElasProp (linmat,prop);
/*
   vfe_LinMatSetDensity (linmat,.0000133);
*/
   vfe_LinMatSetDensity (linmat,1.33);

                   /* Create MatlFun object and load material functions */ 
   matlfun = vfe_MatlFunBegin ();
   vfe_LinMatMatlFun (linmat, matlfun);

                   /* Create shell property object */ 
   beamprop = vfe_BeamPropBegin ();
   vfe_BeamPropDef (beamprop,BEAMPROP_SECTION);
   bprop[0] = 2.000000e-02;
   bprop[1] = 6.666667e-05;
   bprop[2] = 1.666667e-05;
   bprop[3] = 0.;
   bprop[4] = 4.575848e-05;
   bprop[5] = 5./6.;
   bprop[6] = 5./6.;
   bprop[7] = 0.;
   bprop[8] = 0.;
   bprop[9] = 0.;
   vfe_BeamPropSetSection (beamprop,bprop,1);
   vfe_BeamPropSetMatlFun (beamprop,1,matlfun);

                   /* Create MatlFun object and load shell property functions */
   matlfunprop = vfe_MatlFunBegin ();
   vfe_BeamPropMatlFun (beamprop,matlfunprop);

                   /* Create 3D shell element formulation */ 
   beam3d = vfe_Beam3DBegin ();
   vfe_Beam3DSetParami (beam3d,VFE_TECH,VFE_TECH_ISOP);
   vfe_Beam3DSetParami (beam3d,VFE_ROTINERTIA,SYS_ON);
   vfe_Beam3DSetTopology (beam3d,3);

                   /* Register material functions */ 
   vfe_Beam3DSetObject (beam3d,VFE_MATLFUN,matlfunprop);

                   /* Form stiffness matrix */ 
   vfe_Beam3DStiff (beam3d,x,kl);

   printf("Diagonal of stiffness matrix\n");
   for(i = 0; i < 3; i++) {
      for(j = 0; j < 6; j++) {
         k = 6*i+j+1;
         printf("%12.4e ",kl[k*(k+1)/2-1]);
      }
      printf("\n");
   }

                   /* Form consistent mass matrix */ 
   vfe_Beam3DMass (beam3d,x,mc);

                   /* Form diagonal mass matrix */ 
   vfe_Beam3DMassDiag (beam3d,x,md);

   printf("Diagonal mass matrix\n");
   for(i = 0; i < 3; i++) {
      for(j = 0; j < 6; j++) {
         printf("%12.4e ",md[6*i+j]);
      }
      printf("\n");
   }

                   /* Form load vector for constant pressure */ 
   for(i = 0; i < 3; i++) {
      v[i][0] = 1.;
      v[i][1] = 0.;
      v[i][2] = 0.;
   }
   vfe_Beam3DDistLoad (beam3d,x,SYS_EDGE,0,VFE_DISTLOAD_TRAC,(Vdouble*)v,f);

   printf("Constant traction load vector\n");
   for(i = 0; i < 3; i++) {
      for(j = 0; j < 6; j++) {
         printf("%12.4e ",f[6*i+j]);
      }
      printf("\n");
   }

                   /* Delete objects */ 
   vfe_Beam3DEnd (beam3d);
   vfe_MatlFunEnd (matlfun);
   vfe_LinMatEnd  (linmat);
   vfe_MatlFunEnd  (matlfunprop);
   vfe_BeamPropEnd (beamprop);
   return 0;
}

13.7. Example 5, Rigid Body MPC Using Penalty Function

This example illustrates generating multi-point constraints using the MPC module. There are three multi-point constraints in this example which form a tripod and which could be used to transmit forces and moments applied to the single node at the tip of the tripod to the 3 nodes at the base of the tripod. This would be useful to attach a beam element to the face of a tetrahedral solid element. The type of constraint to be modeled is defined using vfe_MPCDef(). The rigid body type constraint is defined which can generally relate the translations and rotations of one node to the translations and rotations of another node which is not coincident with the first node.

In this example the constraint is satisfied using the penalty function technique. The multi-point constraint is represented by a properly constructed stiffness matrix which when assembled into the global stiffness matrix will ensure that the constraint is satisfied approximately. The greater the magnitude of the stiffness coefficients used to satisfy the constraint the more accurate the approximation of the constraint will become. The magnitude of the stiffness coefficients is controlled by the penalty parameter which is specified using vfe_MPCSetParamd(). This parameter is generally chosen to be 4 or 5 orders of magnitude larger than the stiffnesses of the elastic elements to which it is attached. The stiffness of constraint is generated for each link using vfe_MPCStiff(). The number of degrees of freedom in the link stiffness is returned using vfe_MPCNumDof(). In practice, the link stiffness should be assembled into the global system stiffness matrix using the same methodology as any finite element such as a solid, shell or beam.

#include <stdio.h>
#include "base/base.h"
#include "vfe/vfe.h"

static Vint itwo[6] = {2,2,2,2,2,2};

static Vdouble x[3][2][3] = {
  { {0.,0.,1.}, {0.,0.,0.} },
  { {0.,0.,1.}, {1.,0.,0.} },
  { {0.,0.,1.}, {0.,1.,0.} } };

/*----------------------------------------------------------------------
                      Rigid Body MPC Using Penalty Function
----------------------------------------------------------------------*/
int
main()
{
   Vint i, j, n;
   Vint loc[6], tag[6], tagdep[6];
   Vdouble kl[12*(12+1)/2];
   vfe_MPC *mpc;
   Vint nedofs;

                   /* Create MPC object */
   mpc = vfe_MPCBegin ();

                   /* specify rigid body type constraint */ 
   vfe_MPCDef (mpc,MPC_KINE);

                   /* set penalty factor */ 
   vfe_MPCSetParamd (mpc,MPC_PENALTY,1.e+12);

                   /* set RBE info */
   loc[0] = 1;
   loc[1] = 1;
   loc[2] = 1;
   loc[3] = 1;
   loc[4] = 1;
   loc[5] = 1;
   tag[0] = SYS_DOF_TX;
   tag[1] = SYS_DOF_TY;
   tag[2] = SYS_DOF_TZ;
   tag[3] = SYS_DOF_RX;
   tag[4] = SYS_DOF_RY;
   tag[5] = SYS_DOF_RZ;
   tagdep[0] = SYS_DOF_TX;
   tagdep[1] = SYS_DOF_TY;
   tagdep[2] = SYS_DOF_TZ;
   tagdep[3] = SYS_DOF_RX;
   tagdep[4] = SYS_DOF_RY;
   tagdep[5] = SYS_DOF_RZ;
   vfe_MPCSetKine (mpc,loc,tag,6,itwo,tagdep);

                   /* return total number of element dofs */ 
   vfe_MPCNumDof (mpc,VFE_ANALYSIS_STRUCTURAL,&nedofs);

                   /* Form stiffness matrix */ 
   for(n = 0; n < 3; n++) {
      vfe_MPCStiff (mpc,x[n],kl);
      printf("Lower triangle of stiffness matrix, element= %d\n",n+1);
      for(i = 0; i < nedofs; ++i ) {
         for(j = 0; j <= i; ++j) {
            printf("%9.2e ",kl[i*(i+1)/2+j]);
         }
         printf("\n");
      }
   }

                   /* Delete object */ 
   vfe_MPCEnd (mpc);
   return 0;
}

13.8. Example 6, Infinitesimal Elasto-plasticity under Biaxial Stretching

This example illustrates using the PlasMat module to extract the stress originating from a cyclic plastic deformation under a bi-axial state of strain. In the example, all calls to a MatlFun function assume that the PlasMat object has been registered in the MatlFun object.

A Young’s modulus of 206.9 and a Poisson’s ratio of 0.29 are set. The exponential law is chosen as the hardening curve, with a hardening modulus of 16.93 and a hardening exponent of 0.265. The yield stress is chosen as 0.45. The PlasMat module requires that pointers be set for the history variables. The number of required history variables is obtained with a call to vfe_MatlFunNumHist(). Two history variables are allocated: one to store the converged results, and one for the output of the current solution. The arrays hist1 and hist2 are allocated for this purpose, and are set in the PlasMat object. These values must be internally initialized with a call to vfe_MatlFunInitHist(). Users are advised to always use the PlasMat history initialization function, as not all history variables can be initialized to zero.

Two pointers are declared, “curold” and “curnew”. These two pointers will facilitate the updating of the internal variables by a simple swap of the arrays pointed to by these pointers. The material is cycled through a strain history that takes two axial strains through the following path: 0 -> ebar -> -ebar -> ebar, where “ebar” is 10 times the elastic strain as the stress reaches the yield value, or ebar = 10*yield/Elastic modulus

An important point is the fact that as the call to vfe_MatlFunStressDMatrix() is made and the results converged, the converged history variables must be set as the “old” history variables. This is done via the pointer swap mentioned above.

#include <stdlib.h>
#include <stdio.h>
#include "vfe/vfe.h"

/*----------------------------------------------------------------------
         Infinitesimal elasto-plasticity under bi-axial stretching
----------------------------------------------------------------------*/
int
main()
{
   Vint m;
   vfe_PlasMat *plasmat;
   vfe_MatlFun *matlfun;
   Vdouble elasprop[2];
   Vdouble strain[6], stress[6];
   Vdouble yield, hardmod, hardexp, ebar;
   Vdouble *hist1, *hist2, *curold, *curnew, *tmp;
   Vint    nhist;

                   /* Create material object and set properties */ 
   plasmat = vfe_PlasMatBegin ();
   matlfun = vfe_MatlFunBegin ();
   vfe_PlasMatMatlFun (plasmat,matlfun);
   vfe_PlasMatSetParami (plasmat,VFE_STRAINTYPE,VFE_SMALLSTRAIN);
   elasprop[0] = 206.9;
   elasprop[1] = 0.29;
   vfe_PlasMatSetElasProp (plasmat,elasprop);
   vfe_PlasMatDef (plasmat,PLASMAT_EXPLAW);
   yield   = 0.45;
   hardmod = 16.93;
   hardexp = 0.265;
   vfe_PlasMatSetExponent (plasmat,yield,hardmod,hardexp);

                   /* Query number of history variables */
   vfe_MatlFunNumHist (matlfun,&nhist);

                   /* Allocate history variables for single point */
   hist1 = (Vdouble*)malloc(nhist*sizeof(Vdouble));
   hist2 = (Vdouble*)malloc(nhist*sizeof(Vdouble));

                   /* Set pointer to the current old and new histories */
   curold = hist1;
   curnew = hist2;
                   /* Set history pointers and initialize history */
   vfe_MatlFunHistPtr (matlfun,curold,curnew);
   vfe_MatlFunInitHist (matlfun);

                   /* Set strain limits */
   ebar = 10.*yield/elasprop[0];

                   /* Loop over increments (including initialization) */
   printf(" Strain         Stress\n");
   for(m = 0; m <= 100; m++) {
   
                   /* Compute uniform strain for this load increment */
      if(m <= 20) {
         strain[0] = m*ebar/20.;
         strain[1] = strain[0];
      } else if(m > 20 && m <= 60) {
         strain[0] = ebar - (m-20)*ebar/20.;
         strain[1] = strain[0];
      } else if(m > 60 && m <= 100) {
         strain[0] = -ebar + (m-60)*ebar/20.;
         strain[1] = strain[0];
      }
      strain[2] = strain[3] = strain[4] = strain[5] = 0.;

                   /* Compute stress */
      vfe_MatlFunStress (matlfun,strain,stress);
      printf("%12.4e   %12.4e\n",strain[0],stress[0]);

                   /* Swap history */
      tmp    = curnew;
      curnew = curold;
      curold = tmp;
      vfe_MatlFunHistPtr (matlfun,curold,curnew);
   }

                   /* free history variables */
   free(hist1);
   free(hist2);
                   /* Delete object */ 
   vfe_PlasMatEnd (plasmat);
   vfe_MatlFunEnd (matlfun);
   return 0;
}

13.9. Example 7, Mooney-Rivlin Material in Plane Stress

This example illustrates using the HyperMat module to extract the Cauchy stress and the tangent material matrix to be used in a non-linear finite element program. It is assumed that a plane stress state is required, as is the case for plates and shells. The following operations are performed: instance a HyperMat object; set its material properties, including the bulk modulus; set condensation flags for the plane stress condition; and extract the stress and material tangent matrix for a given deformation gradient.

The deformation is defined as an array of 9 numbers, with entries given in the following order: F_xx, F_yx, F_zx, F_xy, F_yy, F_zy, F_xz, F_yz, F_zz. In the example, the entries F_yx and F_xy are set to zero, which will result in no shear stress in the plane of the plate/shell.

The condensation flags indicate that only the zz stress component is to be eliminated. The transverse shear components are assumed present, and are treated elastically, assuming a linear relationship between the transverse shear components and its corresponding infinitesimal strains. A shear constant G is internally computed for this purpose.

The example shows how the Mooney-Rivlin material - and other hyperelastic materials - are generalized. Users are required to enter a bulk modulus to enforce the incompressibility condition. A large value of the bulk modulus enforces this condition in a penalized form.

#include <stdio.h>
#include "vfe/vfe.h"

                   /* define deformation gradient matrix */ 
static Vdouble F[9] = { 2.900, 0.000, 0.029, 
                        0.000, 1.984, 0.029,
                        0.029, 0.029, 1.000 };

/*----------------------------------------------------------------------
                  Mooney-Rivlin material in plane stress
----------------------------------------------------------------------*/
int
main()
{
   Vint i, j, n;
   vfe_HyperMat *hypermat;
   vfe_MatlFun  *matlfun;
   Vdouble bulk, mooney[2], stress[6], dm[21];
   Vint cond[6] = {0,0,1,0,0,0};

                   /* Create material object and set properties */ 
   hypermat = vfe_HyperMatBegin ();
   matlfun = vfe_MatlFunBegin ();
   vfe_HyperMatMatlFun (hypermat,matlfun);
   vfe_HyperMatDef (hypermat,HYPERMAT_MOONEY);
   bulk      = 7.5e+8;
   mooney[0] = 37500.;
   mooney[1] = 375.;
   vfe_HyperMatSetMooney (hypermat,bulk,mooney);

                   /* Set condensation flag for plane stress */
   vfe_MatlFunDCond (matlfun,cond);

                   /* Compute Cauchy stress and tangent matrix */
   vfe_MatlFunStressDMatrix (matlfun,F,SYS_ON,stress,dm);

   printf("Deformation Gradient:\n");
   for(i = 0; i < 3; i++) {
      for(j = 0; j < 3; j++) {
         printf("%12.4e ",F[3*j+i]);
      }
      printf("\n");
   }
   printf("\n");

   printf("Cauchy Stress:\n");
   for(i = 0; i < 6; i++) {
      printf("%12.4e\n",stress[i]);
   }
   printf("\n");

   printf("Tangent Matrix:\n");
   for(n = 0, j = 0; j < 6; j++) {
      for(i = 0; i <= j; i++) {
         printf("%12.4e ",dm[n++]);
      }
      printf("\n");
   }

                   /* Delete object */ 
   vfe_HyperMatEnd (hypermat);
   vfe_MatlFunEnd (matlfun);
   return 0;
}

13.10. Example 8, Corotational Frame for a 3D Solid Element

This example illustrates the use of a Corot object to compute a corotational frame for 3D solid elements. A corotational frame may be used to isolate the effects of large rigid body motions, in particular large rotations, from an element formulation. A Corot object is instanced and applied to the formation of stiffness and reaction force computed using a Solid3D object. The setup of the Solid3D object for computing stiffness and force follows standard practice. The Corot object is first used to transform the element coordinates to an initial corotational frame embedded in the element in its undeformed configuration. This computation is performed using vfe_CorotPull(). A set of element displacements representing a small shearing and a large 60 degree rotation is manufactured and transformed to the corotational system representing the deformed state using vfe_CorotPush(). These transformed displacements along with the transformed element coordinates computed by vfe_CorotPull() are now used as input to the standard vfe_Solid3DReactStiff() function to compute stiffness and reactions in the corotational frame. These element stiffness and force vectors must now be transformed back to the global system using vfe_CorotPush() for normal assembly, factorization and solution.

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "base/base.h"
#include "vfe/vfe.h"

static Vdouble x[8][3] = {
   {0.,0.,0.}, {1.,0.,0.}, {1.,1.,0.}, {0.,1.,0.},
   {0.,0.,1.}, {1.,0.,1.}, {1.,1.,1.}, {0.,1.,1.} };

/*----------------------------------------------------------------------
                      Corotation of a Solid3D element
----------------------------------------------------------------------*/
int
main()
{
   Vint i,j,n;
   vfe_Solid3D *solid3d;
   vfe_MatlFun *matlfun;
   vfe_LinMat  *linmat;
   vfe_Corot   *corot;
   Vdouble prop[2];
   Vdouble x1[8][3], x2[8][3];
   Vint nedofs, loc[24], tag[24];
   Vdouble u[24];
   Vdouble tm[3][3];
   Vdouble rf[24],ke[300];
   Vdouble rot[3][3], angle;

                   /* Create material object and set properties */ 
   linmat = vfe_LinMatBegin ();
   vfe_LinMatDef (linmat,SYS_MAT_ISOTROPIC);
   prop[0] = 1.;
   prop[1] = 0.;
   vfe_LinMatSetElasProp (linmat,prop);

                   /* Create MatlFun object and load material functions */ 
   matlfun = vfe_MatlFunBegin ();
   vfe_LinMatMatlFun (linmat, matlfun);

                   /* Create 3D solid element formulation */ 
   solid3d = vfe_Solid3DBegin ();
   vfe_Solid3DSetParami (solid3d,VFE_TECH,VFE_TECH_MIXED);
   vfe_Solid3DSetTopology (solid3d,SYS_SHAPEHEX,2,0,0);

                   /* Register material functions */ 
   vfe_Solid3DSetObject (solid3d,VFE_MATLFUN,matlfun);

                   /* Determine number of degrees of freedom */ 
   vfe_Solid3DNumDof (solid3d,VFE_ANALYSIS_STRUCTURAL,&nedofs);
   vfe_Solid3DDofMap (solid3d,VFE_ANALYSIS_STRUCTURAL,loc,tag);

                   /* Create corotational object */ 
   corot = vfe_CorotBegin ();
   vfe_CorotSetTopology (corot,SYS_SHAPEHEX,2,0,0);
   vfe_CorotSetMap(corot,nedofs,loc,tag);

                   /* Shear in x-y plane */
   for(n = 0; n < 8; n++) {
      x1[n][0] = x[n][0] + 0.1*x[n][1];
      x1[n][1] = x[n][1];
      x1[n][2] = x[n][2];
   }
                   /* Add a 60-degree rotation in x-y plane */
   angle = acos(-1.)/3;
   rot[0][0] =  cos(angle);
   rot[0][1] = -sin(angle);
   rot[0][2] = 0.;
   rot[1][1] =  cos(angle);
   rot[1][0] =  sin(angle);
   rot[1][2] = 0.;
   rot[2][0] = 0.;
   rot[2][1] = 0.;
   rot[2][2] = 1.;
   for(n = 0; n < 8; n++) {
      for(i = 0; i < 3; i++) {
         x2[n][i] = 0.;
         for(j = 0; j < 3; j++) {
            x2[n][i] += rot[i][j]*x1[n][j];
         }
      }
   }
                   /* Compute element displacements */
   for(n = 0; n < 8; n++) {
      for(i = 0; i < 3; i++) {
         u[3*n + i] = x2[n][i] - x[n][i];
      }
   }
                   /* Pull-back deformation to reference frame */
   vfe_CorotPull (corot,x,u,tm);
   printf("\nNodal displacements in corotated frame:\n");
   printf("Node     ux              uy              uz\n");
   for(n = 0; n < 8; n++) {
      printf("%4d %15.8f %15.8f %15.8f\n",n+1,u[3*n],u[3*n+1],u[3*n+2]);
   }
                   /* Form reaction force and stiffness in reference frame */
   vfe_Solid3DReactStiff (solid3d,x,u,SYS_ON,rf,ke);
   printf("\nReaction forces in inertial frame:\n");
   printf("Node     fx              fy              fz\n");
   for(n = 0; n < 8; n++) {
      printf("%4d %15.8f %15.8f %15.8f\n",n+1,rf[3*n],rf[3*n+1],rf[3*n+2]);
   }
                   /* Push reaction force and stiffness to corotated frame */
   vfe_CorotPush (corot,SYS_ON,rf,SYS_ON,ke);
   printf("\nReaction forces in corotated frame:\n");
   printf("Node     fx              fy              fz\n");
   for(n = 0; n < 8; n++) {
      printf("%4d %15.8f %15.8f %15.8f\n",n+1,rf[3*n],rf[3*n+1],rf[3*n+2]);
   }
                   /* Delete objects */ 
   vfe_Solid3DEnd (solid3d);
   vfe_CorotEnd (corot);
   vfe_MatlFunEnd (matlfun);
   vfe_LinMatEnd (linmat);
   return 0;
}

13.11. Example 9, Rigid Body Mode Detection using NodeGeom

This example illustrates the use of a NodeGeom object to compute unconstrained rigid body modes. A set of four constraints are applied to two nodes. A translational constraint in the y direction and a rotational constraint about the x axis are applied at the first node located at (1.,0.,0.), Translational constraints in the x direction and the y direction are applied at the second node located at (1.,1.,0.), Since there is no translational constraint in the z direction there will be a translational free mode in the z direction. Translational constraints can prevent rotational rigid body modes if there are two translational constraints in the same direction which are offset in space in a direction perpendicular to their direction. The two translational constraints in the y direction are offset parallel to their direction and therefore to not prevent rotation. As a result, even though there are 4 constraints, they only prevent 3 rigid body motions. Two rotational rigid body motions remain, one about the y axis passing through the specified center point and a second about the z axis passing through a point offset by 1. from the center point in the y direction, ie. the location of node 2.

#include "base/base.h"
#include "vfe/vfe.h"

/*----------------------------------------------------------------------
                      Rigid Body Mode Detection using NodeGeom
----------------------------------------------------------------------*/
int
main()
{
   Vint i;
   vfe_NodeGeom *nodegeom;
   Vdouble x[2][3];
   Vint ntags, loc[4], tag[4];
   Vint ntra, nrot;
   Vdouble tra[3][3], rot[3][6], off[3][3];
   Vint mode;

                   /* Create NodeGeom object */
   nodegeom = vfe_NodeGeomBegin ();

                   /* two node coordintes at which 4 constraints applied */ 
   x[0][0] = 1.;
   x[0][1] = 0.;
   x[0][2] = 0.;
   x[1][0] = 1.;
   x[1][1] = 1.;
   x[1][2] = 0.;
                   /* Ty and Rx at first node, Tx and Ty at second node */ 
   ntags = 4;
   loc[0] = 1;
   loc[1] = 1;
   loc[2] = 2;
   loc[3] = 2;
   tag[0] = SYS_DOF_TY;
   tag[1] = SYS_DOF_RX;
   tag[2] = SYS_DOF_TX;
   tag[3] = SYS_DOF_TY;
   
                   /* set center to first node as an example */ 
   vfe_NodeGeomSetCenter (nodegeom,x[0]);

                   /* compute unconstrained rigid body modes */ 
   vfe_NodeGeomFreeMode (nodegeom,x,0,NULL,ntags,loc,tag,
                         &ntra,tra,&nrot,rot,off);

   mode = 0;
                   /* print unconstrained modes */ 
   printf("Translational modes\n");
   for(i = 0; i < ntra; i++) {
      mode += 1;
      printf("mode %d, vector= %e %e %e\n",mode,
              tra[i][0],tra[i][1],tra[i][2]);
   }
   printf("Rotational modes\n");
   for(i = 0; i < nrot; i++) {
      mode += 1;
      printf("mode %d, vector= %e %e %e %e %e %e\n",mode,
              rot[i][0],rot[i][1],rot[i][2], rot[i][3],rot[i][4],rot[i][5]);
      printf("         offset= %e %e %e\n",
              off[i][0],off[i][1],off[i][2]);
   }

                   /* Delete object */ 
   vfe_NodeGeomEnd (nodegeom);
   return 0;
}

13.12. Example 10, Linear Stress Analysis Using 10 Node Tetrahedra

This example illustrates the use of VfeTools and VfsTools to develop the basic framework for linear static analysis using 10 node tetrahedral solid elements. The finite element model is a 1. x 2. x 3. block with a uniform 3 x 3 x 3 grid of nodes and connected by 6 10-node tetrahedral solid elements. Permanent restraints are applied so that the x = 0., y = 0. and z = 0. planes are symmetry planes. Uniform pressure load is applied to the element faces at the x = 1. plane. The material properties are linear elastic with Young’s modulus = 1.e+6 and Poisson’s ratio = .3 . The finite element model data structures appear as simple static arrays in this example.

The solid element stiffness and load computations are performed using the Solid3D module. It is initialized for a 10 node tetrahedral element formulation. The linear elastic material is modelled using a LinMat module. The MatlFun module provides the abstract material function interface to be registered with the Solid3D module.

The global degree of freedom table is generated by looping through all elements and declaring their degree of freedom usage with a DofTab object. All permanent restraints are then defined and the global degree of freedom table may be generated using vfs_DofTabProcess(). The system stiffness matrix, applied force vector and displacement solution vectors are represented by a SysMatrix and two SysVector objects respectively. Three optional solution strategies are implemented, in-core direct sparse solver, out of core direct sparse solver and iterative solver. In practice one of these three technologies would be selected considering element type, problem size and computer resources, in this example the in-core sparse solver is selected. Note that if the iterative solver is selected using the “Fast” preconditioner, then the DofTab object must be given the element topology and node coordinate information as shown.

The structure of the assembled stiffness matrix is determined by the pre-assembly process and then the actual element stiffness matrix computation and assembly can occur. The function vfs_SysMatrixProcess() must be called to perform any processing required before factorization such as degree of freedom reordering to optimize a sparse matrix factorization. The function vfs_SysMatrixFactor() is then called to factorize the matrix. If a direct solver is used, a complete factorization is performed, if the iterative solver is used, a preconditioner is computed.

The equivalent nodal loads due to pressure are computed and assembled into the force SysVector. The displacement under the force is computed using vfs_SysMatrixSolve() and the nodal displacements are printed. The applied pressure places the block under uniform compression stress equal in magnitude to the applied pressure. Finally the stress and strain in each element is computed and printed.

../../_images/vfetools-exam10.gif

Figure 10-1, Finite Element Model of 10-Node Tetrahedra

#include <stdlib.h>
#include "base/basedefs.h"
#include "vfe/vfe.h"
#include "vfs/vfs.h"

                   /* node coordinates for 27 nodes */
static Vdouble xg[27][3] = { {0.0,0.0,0.0}, {0.5,0.0,0.0}, {1.0,0.0,0.0},
                             {0.0,1.0,0.0}, {0.5,1.0,0.0}, {1.0,1.0,0.0},
                             {0.0,2.0,0.0}, {0.5,2.0,0.0}, {1.0,2.0,0.0},
                             {0.0,0.0,1.5}, {0.5,0.0,1.5}, {1.0,0.0,1.5},
                             {0.0,1.0,1.5}, {0.5,1.0,1.5}, {1.0,1.0,1.5},
                             {0.0,2.0,1.5}, {0.5,2.0,1.5}, {1.0,2.0,1.5},
                             {0.0,0.0,3.0}, {0.5,0.0,3.0}, {1.0,0.0,3.0},
                             {0.0,1.0,3.0}, {0.5,1.0,3.0}, {1.0,1.0,3.0},
                             {0.0,2.0,3.0}, {0.5,2.0,3.0}, {1.0,2.0,3.0} };

                   /* element connectivity for 6 10-node tetrahedra */
static Vint ix[6][10]    = { { 1, 9, 7,25, 5, 8, 4,13,17,16},
                             { 1, 9,25,19, 5,17,13,10,14,22},
                             { 9,25,19,27,17,22,14,18,26,23},
                             { 1, 3, 9,19, 2, 6, 5,10,11,14},
                             { 3, 9,19,27, 6,14,11,15,18,23},
                             { 3,27,19,21,15,23,11,12,24,20} };

                   /* permanent node restraints in x, y and z */ 
static Vint xbc[9] = { 1, 4, 7,10,13,16,19,22,25};
static Vint ybc[9] = { 1, 2, 3,10,11,12,19,20,21};
static Vint zbc[9] = { 1, 2, 3, 4, 5, 6, 7, 8, 9};

                   /* pressure loads on second face of elements 5 and 6 */ 
static Vint lface[2][2] = { {5,2}, {6,2} };
static Vdouble pres[10] = {1.,1.,1.,1.,1.,1.,1.,1.,1.,1.};

                   /* material properties */ 
static Vdouble eprop[2] = { 1.e+6, 0.3 };

                   /* nodal degree of freedom types */ 
static Vint doftags[3] = {SYS_DOF_TX,SYS_DOF_TY,SYS_DOF_TZ};

/*----------------------------------------------------------------------
                      Linear Stress Analysis Using 10 Node Tetrahedra
----------------------------------------------------------------------*/
int
main()
{
                   /* VfeTools objects */
   vfe_Solid3D *solid3d;
   vfe_MatlFun *matlfun;
   vfe_LinMat  *linmat;

                   /* VfsTools objects */
   vfs_DofTab    *doftab;
   vfs_SysMatrix *stiff;
   vfs_SysVector *disp, *force;

   Vint    i, k, m, n, no;
   Vint    nloadfaces, nxbc, nybc, nzbc;
   Vint    nix, numel, numnp;
   Vint    method;
   Vint    neq, nre;
   Vint    nedofs, loc[VFE_MAXDOF], tag[VFE_MAXDOF], lm[VFE_MAXDOF];
   Vdouble ke[VFE_MAXDOF*(VFE_MAXDOF+1)/2], f[VFE_MAXDOF], u[VFE_MAXDOF];
   Vdouble x[VFE_MAXNODE][3];
   Vdouble strs[VFE_MAXNODE*6], strn[VFE_MAXNODE*6];

                   /* set problem parameters */
   nloadfaces =  2;
   nxbc       =  9;
   nybc       =  9;
   nzbc       =  9;
   nix        = 10;
   numel      =  6;
   numnp      = 27;

                   /* element initializations */
   solid3d = vfe_Solid3DBegin ();
   vfe_Solid3DSetTopology (solid3d,SYS_SHAPETET,3,0,0);
   vfe_Solid3DNumDof (solid3d,VFE_ANALYSIS_STRUCTURAL,&nedofs);
   vfe_Solid3DDofMap (solid3d,VFE_ANALYSIS_STRUCTURAL,loc,tag);

                   /* material initializations */
   matlfun = vfe_MatlFunBegin ();
   linmat  = vfe_LinMatBegin ();
   vfe_LinMatDef (linmat,SYS_MAT_ISOTROPIC);
   vfe_LinMatSetElasProp (linmat,eprop);
   vfe_LinMatMatlFun (linmat,matlfun);
   vfe_Solid3DSetObject (solid3d,VFE_MATLFUN,matlfun);

                   /* select solver method */
   method = 1;
                   /* declare element degree of freedom usage */
   doftab = vfs_DofTabBegin ();
   vfs_DofTabDef (doftab,numnp,numel);
   vfs_DofTabSetMap (doftab,nedofs,loc,tag);
   for(m = 1; m <= numel; m++) {
      vfs_DofTabSetTopology (doftab,m,SYS_SHAPETET,3,0,0);
      vfs_DofTabElemUse (doftab,m,nix,ix[m-1]);
   }
   if(method == 3) {
      vfs_DofTabSetParami (doftab,DOFTAB_REDUCE,DOFTAB_REDUCE_ITER);
      for(n = 1; n <= numnp; n++) {
         vfs_DofTabSetCoords (doftab,n,xg[n-1]);
      }
   }
                   /* set permanent restraints */
   for(i = 0; i < nxbc; i++) {
      vfs_DofTabNodePerm (doftab,xbc[i],1,&doftags[0]);
   }
   for(i = 0; i < nybc; i++) {
      vfs_DofTabNodePerm (doftab,ybc[i],1,&doftags[1]);
   }
   for(i = 0; i < nzbc; i++) {
      vfs_DofTabNodePerm (doftab,zbc[i],1,&doftags[2]);
   }
   vfs_DofTabProcess (doftab,&neq,&nre);
   printf("Number of equations: %d\n",neq);
   printf("Number of reactions: %d\n",nre);

                   /* define system matrix and vectors */
   stiff = vfs_SysMatrixBegin ();
   vfs_SysMatrixSetObject (stiff,VFS_DOFTAB,(Vobject*)doftab);
   disp = vfs_SysVectorBegin ();
   vfs_SysVectorDef (disp,neq);
   force = vfs_SysVectorBegin ();
   vfs_SysVectorDef (force,neq);

                   /* in-core sparse solver */
   if(method == 1) {
      printf("In core sparse solver\n");
      vfs_SysMatrixDef (stiff,SYSMATRIX_SYMM_SPARSE,neq);
      vfs_SysMatrixSetParami (stiff,SYSMATRIX_SOLVERTYPE,
                              SYSMATRIX_SOLVERTYPE_MFP);

                   /* out-of-core sparse solver */
   } else if(method == 2) {
      printf("Out of core sparse solver\n");
      vfs_SysMatrixDef (stiff,SYSMATRIX_SYMM_SPARSE,neq);
      vfs_SysMatrixSetParami (stiff,SYSMATRIX_TECH,SYSMATRIX_TECH_SPARSE);
      vfs_SysMatrixSetParami (stiff,SYSMATRIX_SOLVERTYPE,
                              SYSMATRIX_SOLVERTYPE_MFP);
      vfs_SysMatrixSetParami (stiff,SYSMATRIX_FACTOR_OOC,SYS_ON);
      vfs_SysMatrixSetOocFile (stiff,SYSMATRIX_KFACTOR_FILE,"outofcore.ooc");

                   /* iterative solver */
   } else if(method == 3) {
      printf("Iterative solver\n");
      vfs_SysMatrixDef (stiff,SYSMATRIX_SYMM_ITER,neq);
      vfs_SysMatrixSetParami (stiff,SYSMATRIX_SOLVERTYPE,
                              SYSMATRIX_SOLVERTYPE_MFP);
   }

                   /* preprocess stiffness matrix */
   vfs_SysMatrixPreProcess (stiff);
   vfs_SysMatrixInit (stiff,0.);

                   /* assemble stiffness matrix */
   for(m = 1; m <= numel; m++) {
      for(i = 0; i < nix; i++) {
         n = ix[m-1][i];
         x[i][0] = xg[n-1][0];
         x[i][1] = xg[n-1][1];
         x[i][2] = xg[n-1][2];
      }
      vfe_Solid3DStiff (solid3d,x,ke);
      vfs_DofTabElemDof (doftab,m,nix,ix[m-1],&nedofs,lm);
      vfs_SysMatrixAssem (stiff,nedofs,lm,ke);
   }
                   /* factor stiffness matrix */
   vfs_SysMatrixProcess (stiff);
   vfs_SysMatrixFactor (stiff);

                   /* form distributed load on element faces and assemble */
   vfs_SysVectorInit (force,0.0);
   for(k = 0; k < nloadfaces; k++) {
      m  = lface[k][0];
      no = lface[k][1];
      for(i = 0; i < nix; i++) {
         n = ix[m-1][i];
         x[i][0] = xg[n-1][0];
         x[i][1] = xg[n-1][1];
         x[i][2] = xg[n-1][2];
      }
      vfe_Solid3DDistLoad (solid3d,x,SYS_FACE,no,VFE_DISTLOAD_PRES,pres,f);
      vfs_DofTabElemDof (doftab,m,nix,ix[m-1],&nedofs,lm);
      vfs_SysVectorAssem (force,nedofs,lm,f);
   }

                   /* solve for displacements */
   vfs_SysMatrixSolve (stiff,force,disp);

                   /* print displacements */
   printf("Displacements:\n");
   printf("  Node   ux       uy       uz\n");
   for(n = 1; n <= numnp; n++) {
      vfs_DofTabNodeDof (doftab,n,3,doftags,lm);
      for(i = 0; i < 3; i++)  u[i] = 0.;
      vfs_SysVectorGather (disp,3,lm,u);
      printf("  %4d %8.1e %8.1e %8.1e\n",n,u[0],u[1],u[2]);
   }
   printf("\n");

                   /* compute and print stresses and strains */
   for(m = 1; m <= numel; m++) {
      for(i = 0; i < nix; i++) {
         n = ix[m-1][i];
         x[i][0] = xg[n-1][0];
         x[i][1] = xg[n-1][1];
         x[i][2] = xg[n-1][2];
      }
      vfs_DofTabElemDof (doftab,m,nix,ix[m-1],&nedofs,lm);
      for(i = 0; i < nedofs; i++)  u[i] = 0.;
      vfs_SysVectorGather (disp,nedofs,lm,u);
      vfe_Solid3DStrsStrn (solid3d,x,u,strs,strn);
      printf("Element %2d\n\n",m);
      printf("  Node   exx      eyy      ezz      exy      eyz      ezx\n");
      for(i = 0; i < nix; i++) {
         printf("%6d %8.1e %8.1e %8.1e %8.1e %8.1e %8.1e\n",
                i+1,strn[6*i  ],strn[6*i+1],strn[6*i+2],
                    strn[6*i+3],strn[6*i+4],strn[6*i+5]);
      }
      printf("\n");
      printf("  Node   sxx      syy      szz      sxy      syz      szx\n");
      for(i = 0; i < nix; i++) {
         printf("%6d %8.1e %8.1e %8.1e %8.1e %8.1e %8.1e\n",
                i+1,strs[6*i  ],strs[6*i+1],strs[6*i+2],
                    strs[6*i+3],strs[6*i+4],strs[6*i+5]);
      }
      printf("\n");
   }

                   /* delete objects */ 
   vfe_Solid3DEnd (solid3d);
   vfe_MatlFunEnd (matlfun);
   vfe_LinMatEnd (linmat);
   vfs_SysVectorEnd (disp);
   vfs_SysVectorEnd (force);
   vfs_SysMatrixEnd (stiff);
   vfs_DofTabEnd (doftab);
   return 0;
}

13.13. Example 10a, Linear Stress Analysis Using 3D Solid Elements

This example is a generalization of Example 10 in which a finite element model definition is loaded from a VdmTools native .vdm file into a VisTools Model object hierarchy. The solution sequences defined in the finite element model are solved and the resulting displacements and stresses are saved on the input .vdm file. The finite element model may contain any mixture of 3D solid elements. The load cases may consist of distributed tractions on element faces and thermal loads. This example could be extended in a straight forward way to include concentrated nodal forces, body forces, etc.

An initial .vdm file containing a finite element model may be generated using VisTools example vis/exam/exam49vdm.c. The resulting .vdm file may be visualized using VisTools example vis/exam/exam30edev.c.

#include <stdlib.h>
#include "base/base.h"
#include "vfe/vfe.h"
#include "vfs/vfs.h"
#include "vis/vis.h"
#include "vdm/vdm.h"

                   /* useful macro for parsing group activity flags */
#define VIEW_FLAG(flags,ind) (((flags) >> ((ind)-1)) & 1)

static void
LoadMatl(vsy_HashTable *matlfunh, vis_MProp *mprop, Vint mid);
static void
SolidProp(Vint m, vis_Connect *connect, vfe_Solid3D *solid3d,
          vsy_HashTable *matlfunh, vsy_HashTable *eproph,
          Vint *nix, Vint ix[], Vdouble x[][3], vfe_MatlFun **matlfun);
static void
SolidTopo(Vint m, vis_Connect *connect, vfe_Solid3D *solid3d,
          Vint *nedofs, Vint loc[], Vint tag[]);

                   /* nodal degree of freedom types */ 
static Vint doftags[3] = {SYS_DOF_TX,SYS_DOF_TY,SYS_DOF_TZ};

/*----------------------------------------------------------------------
                      Linear Stress Analysis Using VisTools and VdmTools
----------------------------------------------------------------------*/
int
main(int argc, char **argv)
{
                   /* VfeTools objects */
   vfe_Solid3D *solid3d;
   vfe_MatlFun *matlfun;
   vfe_LinMat  *linmat;

                   /* VfsTools objects */
   vfs_DofTab    *doftab;
   vfs_SysMatrix *stiff;
   vfs_SysVector *disp, *forc;

                   /* VisTools objects */
   vis_Model     *model;
   vis_Connect   *connect;
   vis_GridFun   *gridfun;
   vis_MProp     *mprop;
   vis_SProp     *sprop;
   vis_RCase     *rcase;
   vis_LCase     *lcase;
   vis_State     *state;
   vis_Group     *group;
   vis_RProp     *rprop;

                   /* VdmTools objects */
   vdm_DataFun   *datafun;
   vdm_NatLib    *natlib;
   vdm_LMan      *lman;

                   /* Base object */
   vsy_HashTable *mproph;
   vsy_HashTable *eproph;
   vsy_HashTable *matlfunh;
   vsy_HashTable *rcaseh;
   vsy_HashTable *lcaseh;
   vsy_List      *spropl;

   Vchar   path[256];

   Vdouble x[VFE_MAXNODE][3];
   Vdouble ke[VFE_MAXDOF*(VFE_MAXDOF+1)/2];
   Vdouble r[VFE_MAXDOF], f[3*VFE_MAXNODE], u[VFE_MAXDOF];
   Vdouble strs[6*VFE_MAXNODE], strn[6*VFE_MAXNODE];
   Vdouble etemp[VFE_MAXNODE], *temp;
   Vdouble value;

   Vint i, j, l, m, n;
   Vint numel, numnp;
   Vint neq, nre;
   Vint nfaces, no, flags, ntypes, itype[4];
   Vint nedofs, loc[VFE_MAXDOF], tag[VFE_MAXDOF], lm[VFE_MAXDOF];
   Vint nix, ix[VFE_MAXNODE];
   Vint featype;
   Vint shape, maxi, maxj, maxk;
   Vint ntags, rtag[3], type, master;
   Vint mid, sid;
   Vint rcaseidold, rcaseid;
   Vint maxlcaseids, *lcaseids, nlcases;
   Vint itrac, tstrain;
   Vint ierr;

                   /* check for proper number of arguments */
   if(argc < 2) {
      fprintf(stderr,"Usage: %s input/outputfile\n",argv[0]);
      fprintf(stderr," input/outputfile is blank, exam10adev.vdm is assumed\n");
      strcpy(path,"exam10adev.vdm");
   } else {
      strcpy(path,argv[1]);
   }

                   /* open native input file */
   datafun = vdm_DataFunBegin ();
   natlib  = vdm_NatLibBegin ();
   vdm_NatLibDataFun (natlib,datafun);
   vdm_DataFunSetStatus (datafun,VDM_STATUS_ADD);
   vdm_DataFunSetConvention (datafun,VDM_CONVENTION_DOUBLE);
   vdm_DataFunOpen (datafun,0,path,VDM_NATIVE);
   ierr = vdm_DataFunError(datafun);
   if(ierr) {
      fprintf(stderr,"Error: opening file %s\n",path);
      exit(1);
   }
                   /* create lman as helper object */
   lman = vdm_LManBegin ();
   vdm_LManSetObject (lman,VDM_DATAFUN,datafun);

                   /* load model */
   model = vis_ModelBegin ();
   vdm_LManLoadModel (lman,model);

                   /* extract Connect object */ 
   vis_ModelGetObject (model,VIS_CONNECT,(Vobject**)&connect);
   vis_ConnectNumber (connect,SYS_NODE,&numnp);
   vis_ConnectNumber (connect,SYS_ELEM,&numel);
   printf("Number of nodes=     %10d\n",numnp);
   printf("Number of elements=  %10d\n",numel);

                   /* check for 3D solid elements only */ 
   for(m = 1; m <= numel; m++) {
      vis_ConnectElemAssoc (connect,VIS_FEATYPE,1,&m,&featype);
      vis_ConnectTopology (connect,m,&shape,&maxi,&maxj,&maxk);
      if(featype != SYS_ELEM_SOLID  ||
         (shape != SYS_SHAPETET  &&
          shape != SYS_SHAPEWED  &&
          shape != SYS_SHAPEHEX)) {
         printf("Error: Unsupported element type, exiting\n");
         exit(0);
      }
   }

                   /* element initializations */
   solid3d = vfe_Solid3DBegin ();
   for(i = 0; i < VFE_MAXNODE; i++) {
      etemp[i] = 0.;
   }
   vfe_Solid3DSetPropPtr (solid3d,VFE_PROP_TEMPERATURE,etemp);

                   /* material initializations */
   vis_ModelGetHashTable (model,VIS_MPROP,&mproph);
   matlfunh = vsy_HashTableBegin ();
   vsy_HashTableInitIter (mproph);
   while(vsy_HashTableNextIter(mproph,&mid,(Vobject**)&mprop), mprop) {
      LoadMatl (matlfunh,mprop,mid);
   }

   vis_ModelGetHashTable (model,VIS_EPROP,&eproph);

                   /* instance VfsTools objects */
   doftab = vfs_DofTabBegin ();
   stiff  = vfs_SysMatrixBegin ();
   disp   = vfs_SysVectorBegin ();
   forc   = vfs_SysVectorBegin ();

                   /* create auxiliary group for distributed loads */
   group = vis_GroupBegin ();

                   /* create output state */
   state   = vis_StateBegin ();
   gridfun = vis_GridFunBegin ();
   vis_ConnectGridFun (connect,gridfun);
   vis_StateSetObject (state,VIS_GRIDFUN,gridfun);
   rprop = vis_RPropBegin ();

                   /* allocate temperature array */
   temp = (Vdouble*)malloc(numnp*sizeof(Vdouble));

                   /* extract load case information */
   vis_ModelGetHashTable (model,VIS_LCASE,&lcaseh);
   vsy_HashTableCount (lcaseh,&maxlcaseids);
   lcaseids = (Vint*)malloc(maxlcaseids*sizeof(Vint));

                   /* extract restraint case information */ 
   vis_ModelGetHashTable (model,VIS_RCASE,&rcaseh);
   rcaseidold = -1;

                   /* loop over solution properties */ 
   vis_ModelGetList (model,VIS_SPROP,&spropl);
   vsy_ListInitIter (spropl);
   while(vsy_ListNextIter(spropl,&sid,(Vobject**)&sprop),sprop) {

                   /* generate degree of freedom table */
      vis_SPropValueInteger (sprop,SPROP_RCASE,&rcaseid);

                   /* check whether restraint set has changed */
      if(rcaseid != rcaseidold) {
         vfs_DofTabDef (doftab,numnp,numel);
         for(m = 1; m <= numel; m++) {
            vis_ConnectElemNode (connect,m,&nix,ix);
            SolidTopo (m,connect,solid3d,&nedofs,loc,tag);
            vfs_DofTabSetMap (doftab,nedofs,loc,tag);
            vfs_DofTabElemUse (doftab,m,nix,ix);
         }

                   /* process zero boundary conditions */
         if(rcaseid) {
            vsy_HashTableLookup (rcaseh,rcaseid,(Vobject**)&rcase);
            for(n = 1; n <= numnp; n++) {
               vis_RCaseSPCTag (rcase,n,&ntags,rtag);
               if(ntags) {
                  for(i = 0; i < ntags; i++) {
                     vis_RCaseSPCdv (rcase,n,rtag[i],&type,&value,&master);
                     if(type == RCASE_FIXED) {
                        vfs_DofTabNodePerm (doftab,n,1,&rtag[i]);
                     }
                  }
               }
            }
         }
         vfs_DofTabProcess (doftab,&neq,&nre);
         printf("Number of equations= %10d\n",neq);
         printf("Number of reactions= %10d\n",nre);

                   /* define sparse system matrix and vectors */
         vfs_SysMatrixDef (stiff,SYSMATRIX_SYMM_SPARSE,neq);
         vfs_SysVectorDef (disp,neq);
         vfs_SysVectorDef (forc,neq);

                   /* pre-process stiffness matrix */
         vfs_SysMatrixSetObject (stiff,VFS_DOFTAB,(Vobject*)doftab);
         vfs_SysMatrixPreProcess (stiff);

                   /* initialize matrix */
         vfs_SysMatrixInit (stiff,0.);

                   /* form and assemble stiffness matrix */
         printf("Form and assemble stiffness matrix\n");
         for(m = 1; m <= numel; m++) {
            SolidProp (m,connect,solid3d,matlfunh,eproph,&nix,ix,x,&matlfun);
            SolidTopo (m,connect,solid3d,&nedofs,loc,tag);
            vfs_DofTabElemDof (doftab,m,nix,ix,&nedofs,lm);
            vfe_Solid3DStiff (solid3d,x,ke);
            vfs_SysMatrixAssem (stiff,nedofs,lm,ke);
         }
                   /* process stiffness matrix */ 
         printf("Process stiffness matrix\n");
         vfs_SysMatrixProcess (stiff);
                   /* factor stiffness */
         printf("Factor stiffness matrix\n");
         vfs_SysMatrixFactor (stiff);
      }
      rcaseidold = rcaseid;

                   /* loop over load cases */
      printf("Generating load for solution sequence= %3d\n",sid);
      vis_SPropValueInteger (sprop,SPROP_LCASE_NUM,&nlcases);
      vis_SPropValueInteger (sprop,SPROP_LCASE,lcaseids);
      
                   /* loop over load cases to be added */
      vfs_SysVectorInit (forc,0.);
      itrac = 0;
      tstrain = 0;
      vis_SPropValueInteger (sprop,SPROP_THERMALSTRAIN,&tstrain);
      for(l = 0; l < nlcases; l++) {
      
                   /* extract load case */
         vsy_HashTableLookup (lcaseh,lcaseids[l],(Vobject**)&lcase);

                   /* face based distributed loads */ 
         vis_GroupDef (group,numel,SYS_ELEM,SYS_FACE);
         vis_LCaseFaceGroup (lcase,NULL,group);
         vis_GroupInitIndex (group);
         while(vis_GroupNextIndex (group,&m,&flags),m) {
            SolidProp (m,connect,solid3d,matlfunh,eproph,&nix,ix,x,&matlfun);
            SolidTopo (m,connect,solid3d,&nedofs,loc,tag);
            vfs_DofTabElemDof (doftab,m,nix,ix,&nedofs,lm);
            vis_ConnectElemNum (connect,SYS_FACE,m,&nfaces);
            for(no = 1; no <= nfaces; no++) {
               if(VIEW_FLAG(flags,no) == 0) continue;
               vis_LCaseDistType (lcase,SYS_FACE,m,no,&ntypes,itype);
               for(i = 0; i < ntypes; i++) {
                  if(itype[i] == LCASE_TRAC) {
                     itrac = 1;
                     for(j = 0; j < 3*VFE_MAXNODE; j++) {
                        f[j] = 0.;
                     }
                     vis_LCaseDistdv (lcase,SYS_FACE,m,no,itype[i],1,f);
                     vfe_Solid3DDistLoad (solid3d,x,SYS_FACE,no,itype[i],f,r);
                     vfs_SysVectorAssem (forc,nedofs,lm,r);
                  }
               }
            }
         }
                   /* node based thermal loads */ 
         if(tstrain) {
            for(i = 0; i < numnp; i++) {
               temp[i] = 0.;
            }
            vis_GroupDef (group,numnp,SYS_NODE,SYS_NONE);
            vis_LCaseNodeGroup (lcase,NULL,group);
            vis_GroupInitIndex (group);
            while (vis_GroupNextIndex (group,&n,&flags), n) {
               vis_LCaseConcType (lcase,n,&ntypes,itype);
               for(i = 0; i < ntypes; i++) {
                  if(itype[i] == LCASE_TEMP) {
                     vis_LCaseConcdv (lcase,n,LCASE_TEMP,&temp[n-1]);
                  }
               }
            }
   
            for(m = 1; m <= numel; m++) {
               SolidProp (m,connect,solid3d,matlfunh,eproph,&nix,ix,x,&matlfun);
               vfe_MatlFunGetObj (matlfun,(Vobject**)&linmat);
               vfe_LinMatSetParami (linmat,VFE_THERMALSTRAIN,SYS_ON);
               SolidTopo (m,connect,solid3d,&nedofs,loc,tag);
               for(i = 0; i < nix; i++) {
                  etemp[i] = temp[ix[i]-1];
               }
               for(i = 0; i < nedofs; i++) {
                  u[i] = 0.;
               }
               vfs_DofTabElemDof (doftab,m,nix,ix,&nedofs,lm);
               vfe_Solid3DReact (solid3d,x,u,r);
               vfs_SysVectorAssem (forc,nedofs,lm,r);
            }
         }
      }
      if(itrac) {
         printf("Distributed traction detected\n");
      }
      if(tstrain) {
         printf("Thermal strains detected\n");
      }
   
                      /* solve for displacements */
      printf("Solve system\n");
      vfs_SysMatrixSolve (stiff,forc,disp);

                   /* save displacements */
      printf("Save results\n");
      vis_StateDef (state,numnp,SYS_NODE,SYS_NONE,SYS_VECTOR);
      for(n = 1; n <= numnp; n++) {
         u[0] = u[1] = u[2] = 0.;
         vfs_DofTabNodeDof (doftab,n,3,doftags,lm);
         vfs_SysVectorGather (disp,3,lm,u);
         vis_StateSetDatadv (state,n,u);
      }
      vis_RPropDef (rprop,SYS_NODE,SYS_NONE);
      vis_RPropSetValuec (rprop,RPROP_TITLE,"exam10adev");
      vis_RPropSetType (rprop,SYS_RES_D);
      vis_RPropSetIds (rprop,sid,1,0);
      vdm_LManSaveState (lman,state,rprop);

                   /* save stresses */
      vis_StateDef (state,numel,SYS_ELEM,SYS_NODE,SYS_TENSOR);
      vis_StateSetObject (state,VIS_GRIDFUN,gridfun);
      vis_RPropDef (rprop,SYS_ELEM,SYS_NODE);
      vis_RPropSetValuec (rprop,RPROP_TITLE,"exam10adev");
      vis_RPropSetType (rprop,SYS_RES_S);
      vis_RPropSetIds (rprop,sid,1,0);
      for(m = 1; m <= numel; m++) {
         SolidProp (m,connect,solid3d,matlfunh,eproph,&nix,ix,x,&matlfun);
         SolidTopo (m,connect,solid3d,&nedofs,loc,tag);
         for(i = 0; i < nedofs; i++) {
            u[i] = 0.;
         }
         vfs_DofTabElemDof (doftab,m,nix,ix,&nedofs,lm);
         vfs_SysVectorGather (disp,nedofs,lm,u);
         vfe_Solid3DStrsStrn (solid3d,x,u,strs,strn);
         vis_StateSetDatadv (state,m,strs);
      }
      vdm_LManSaveState (lman,state,rprop);
   }
   vdm_DataFunClose (datafun);

                   /* delete objects */
   vdm_DataFunEnd (datafun);
   vdm_NatLibEnd  (natlib);
   vdm_LManEnd    (lman);
   vis_ModelDelete(model);
   vis_ModelEnd   (model);
   vfe_Solid3DEnd (solid3d);
   vsy_HashTableInitIter (matlfunh);
   while (vsy_HashTableNextIter (matlfunh,&mid,(Vobject**)&matlfun), matlfun) {
      vfe_MatlFunGetObj (matlfun,(Vobject**)&linmat);
      vfe_LinMatEnd (linmat);
   }
   vsy_HashTableForEach (matlfunh,(void(*)(Vobject*))vfe_MatlFunEnd);
   vsy_HashTableEnd (matlfunh);
   vfs_DofTabEnd    (doftab);
   vfs_SysMatrixEnd (stiff);
   vfs_SysVectorEnd (disp);
   vfs_SysVectorEnd (forc);
   vis_GroupEnd     (group);
   vis_StateEnd     (state);
   vis_GridFunEnd   (gridfun);
   vis_RPropEnd     (rprop);
   free(lcaseids);
   if(tstrain) {
      free(temp);
   }
   return 0;
}

/*----------------------------------------------------------------------
                      load material
----------------------------------------------------------------------*/
static void
LoadMatl(vsy_HashTable *matlfunh, vis_MProp *mprop, Vint mid)
{
   Vint i;
   Vint youngflag, poissonflag;
   Vint ntypes,mattype[MPROP_MAX];
   Vdouble tref, alpha, values[2];
   vfe_LinMat  *linmat;
   vfe_MatlFun *matlfun;

   linmat = vfe_LinMatBegin ();
   vfe_LinMatDef (linmat,SYS_MAT_ISOTROPIC);
   vis_MPropValueType (mprop,&ntypes,mattype);
   youngflag = poissonflag = 0;
   for(i = 0; i < ntypes; i++) {
      if(mattype[i] == MPROP_E) {
         vis_MPropValueDouble (mprop,MPROP_E,&values[0]);
         youngflag = 1;
      } else if(mattype[i] == MPROP_NU) {
         vis_MPropValueDouble (mprop,MPROP_NU,&values[1]);
         poissonflag = 1;
      } else if(mattype[i] == MPROP_TREF) {
         vis_MPropValueDouble (mprop,MPROP_TREF,&tref);
         vfe_LinMatSetRefTemp (linmat,tref);
      } else if(mattype[i] == MPROP_A) {
         vis_MPropValueDouble (mprop,MPROP_A,&alpha);
         vfe_LinMatSetThermExp (linmat,&alpha);
      }
   }

   /* Both Young's modulus and Poisson's ratio must be defined */
   if(youngflag && poissonflag) {
      vfe_LinMatSetElasProp (linmat,values);
   }
   matlfun = vfe_MatlFunBegin ();
   vfe_LinMatMatlFun (linmat,matlfun);

   /* orthotropic material */
   vsy_HashTableInsert (matlfunh,mid,matlfun);
}

/*----------------------------------------------------------------------
                      solid element properties
----------------------------------------------------------------------*/
static void
SolidProp(Vint m, vis_Connect *connect, vfe_Solid3D *solid3d,
          vsy_HashTable *matlfunh, vsy_HashTable *eproph,
          Vint *nix, Vint ix[], Vdouble x[][3], vfe_MatlFun **matlfun)
{
   Vint pid, mid;
   vis_EProp *eprop;

   vis_ConnectElemNode  (connect,m,nix,ix);
   vis_ConnectCoordsdv (connect,*nix,ix,x);
   vis_ConnectElemAssoc (connect,VIS_PROPID,1,&m,&pid);
   if(eproph) vsy_HashTableLookup (eproph,pid,(Vobject**)&eprop);
                   /* use material id */ 
   if(eprop == NULL) {
      vis_ConnectElemAssoc (connect,VIS_MATLID,1,&m,&mid);
      vsy_HashTableLookup (matlfunh,mid,(Vobject**)matlfun);
                   /* use material id from element property */ 
   } else {
      vis_EPropValueInteger (eprop,EPROP_MID,&mid);
      vsy_HashTableLookup (matlfunh,mid,(Vobject**)matlfun);
   }
   vfe_Solid3DSetObject (solid3d,VFE_MATLFUN,*matlfun);
}

/*----------------------------------------------------------------------
                      solid element topology and degrees of freedom
----------------------------------------------------------------------*/
static void
SolidTopo(Vint m, vis_Connect *connect, vfe_Solid3D *solid3d,
          Vint *nedofs, Vint loc[], Vint tag[])
{
   Vint shape, maxi, maxj, maxk;
   Vint featech;

                   /* set element topology */ 
   vis_ConnectTopology (connect,m,&shape,&maxi,&maxj,&maxk);
   vfe_Solid3DSetTopology (solid3d,shape,maxi,maxj,maxk);

                   /* set element technology */ 
   vis_ConnectElemAssoc (connect,VIS_FEATECH,1,&m,&featech);
                   /* not specified so set a reasonable technology */ 
   if(featech == 0) {
      if(shape == SYS_SHAPETET) {
         featech = SYS_TECH_ISOP;
      } else if(shape == SYS_SHAPEWED) {
         if(maxi == 3) {
            featech = SYS_TECH_ISOP;
         } else {
            featech = SYS_TECH_MIXED;
         }
      } else if(shape == SYS_SHAPEHEX) {
         featech = SYS_TECH_MIXED;
      }
   }
   vfe_Solid3DSetParami (solid3d,VFE_TECH,featech);

                   /* query degree of freedom information */ 
   vfe_Solid3DNumDof (solid3d,VFE_ANALYSIS_STRUCTURAL,nedofs);
   vfe_Solid3DDofMap (solid3d,VFE_ANALYSIS_STRUCTURAL,loc,tag);
}

13.14. Example 11, Generate Gradients of Shape Functions

This example illustrates computing shape functions and gradients at element nodes and element centroid in solid elements using vfe_Solid2DShapeGrad() and vfe_Solid3DShapeGrad().

#include <stdio.h>
#include "vfe/vfe.h"

static Vdouble x3d[10][3] = {
   {  0., 0., 0.}, {10., 0., 0.}, {  0.,10., 0.}, {  0., 0.,10.},
   {  5., 0., 0.}, { 5., 5., 0.}, {  0., 5., 0.},
   {  0., 0., 5.}, { 5., 0., 5.}, {  0., 5., 5.} };

static Vint nix3d = 10;

static Vdouble x2d[4][3] = {
   {  0.,  0.,  0. }, { 10.,  0.,  0.}, { 10., 10.,  0.}, {  0., 10.,  0.}};

static Vdouble x2dxz[4][3] = {
   {  0.,  0.,  0. }, { 10.,  0.,  0.}, { 10.,  0., 10.}, {  0.,  0., 10.}};

static Vint nix2d = 4;

/*----------------------------------------------------------------------
                      Generate Gradients of Shape Functions
----------------------------------------------------------------------*/
int
main() {
   vfe_Solid3D *solid3d;
   vfe_Solid2D *solid2d;
   Vdouble phr3d[64*64][3], phx[64*64][3], h[64*64], dj[64], phr2d[16*16][2];
   Vint node, ipt, ind;

                   /* instance Solid3D */
   printf("Solid3D:\n");
   solid3d = vfe_Solid3DBegin ();
                   /* set solid3d topology */
   vfe_Solid3DSetTopology (solid3d,SYS_SHAPETET,3,0,0);

                   /* compute gradients of shape functions at element nodes */ 
   vfe_Solid3DShapeGrad (solid3d,x3d,SYS_OFF,h,phr3d,dj,phx);
   for(ipt = 0; ipt < nix3d; ++ipt) {
      printf("Point location = node %d, dj= %e\n",ipt+1, dj[ipt]);
      if(dj[ipt] == 0.)  continue;

      for(node = 0; node < nix3d; ++node) {
         ind = nix3d*ipt+node;
         printf("   node= %2d, %11.4e  %11.4e %11.4e %11.4e\n",node+1,
                    h[ind],phx[ind][0],phx[ind][1],phx[ind][2]);
      }
   }
                   /* compute gradients of shape functions at centroid */ 
   vfe_Solid3DShapeGrad (solid3d,x3d,SYS_ON,h,phr3d,dj,phx);
   printf("Point location = centroid, dj= %e\n",dj[0]);

   if(dj[0] != 0.) {
      for(node = 0; node < nix3d; ++node) {
         printf("   node= %2d, %11.4e  %11.4e %11.4e %11.4e\n",node+1,
                    h[node],phx[node][0],phx[node][1],phx[node][2]);
      }
   }
                   /* delete Solid3D */ 
   vfe_Solid3DEnd (solid3d);

                   /* instance Solid2D */
   printf("\nSolid2D in x-y plane:\n");
   solid2d = vfe_Solid2DBegin ();
                   /* set solid2d topology */
   vfe_Solid2DSetTopology (solid2d,SYS_SHAPEQUAD,2,0);

                   /* compute gradients of shape functions at element nodes */ 
   vfe_Solid2DShapeGrad (solid2d,x2d,SYS_OFF,h,phr2d,dj,phx);
   for(ipt = 0; ipt < nix2d; ++ipt) {
      printf("Point location = node %d, dj= %e\n",ipt+1, dj[ipt]);
      if(dj[ipt] == 0.)  continue;

      for(node = 0; node < nix2d; ++node) {
         ind = nix2d*ipt+node;
         printf("   node= %2d, %11.4e  %11.4e %11.4e %11.4e\n",node+1,
                    h[ind],phx[ind][0],phx[ind][1],phx[ind][2]);
      }
   }
                   /* compute gradients of shape functions at centroid */ 
   vfe_Solid2DShapeGrad (solid2d,x2d,SYS_ON,h,phr2d,dj,phx);
   printf("Point location = centroid, dj= %e\n",dj[0]);

   if(dj[0] != 0.) {
      for(node = 0; node < nix2d; ++node) {
         printf("   node= %2d, %11.4e  %11.4e %11.4e %11.4e\n",node+1,
                    h[node],phx[node][0],phx[node][1],phx[node][2]);
      }
   }
                   /* assume 2D element on x-z plane instead */
   printf("\nSolid2D in x-z plane:\n");
   vfe_Solid2DSetParami (solid2d,VFE_2DXZ,SYS_ON);

                   /* compute gradients of shape functions at element nodes */ 
   vfe_Solid2DShapeGrad (solid2d,x2dxz,SYS_OFF,h,phr2d,dj,phx);
   for(ipt = 0; ipt < nix2d; ++ipt) {
      printf("Point location = node %d, dj= %e\n",ipt+1, dj[ipt]);
      if(dj[ipt] == 0.)  continue;

      for(node = 0; node < nix2d; ++node) {
         ind = nix2d*ipt+node;
         printf("   node= %2d, %11.4e  %11.4e %11.4e %11.4e\n",node+1,
                    h[ind],phx[ind][0],phx[ind][1],phx[ind][2]);
      }
   }
                   /* compute gradients of shape functions at centroid */ 
   vfe_Solid2DShapeGrad (solid2d,x2dxz,SYS_ON,h,phr2d,dj,phx);
   printf("Point location = centroid, dj= %e\n",dj[0]);

   if(dj[0] != 0.) {
      for(node = 0; node < nix2d; ++node) {
         printf("   node= %2d, %11.4e  %11.4e %11.4e %11.4e\n",node+1,
                    h[node],phx[node][0],phx[node][1],phx[node][2]);
      }
   }
                   /* delete Solid2D */ 
   vfe_Solid2DEnd (solid2d);
   return 0;
}

13.15. Example 20, Generate Flexible Body Using Component Mode Synthesis

This extensive example illustrates the use of VfeTools, VfsTools, VisTools and Base modules to build a full scale finite element solver for generating superelements using component mode synthesis. Superelements built in this fashion can be used in multi-body simulation systems to model flexible components. VisTools and Base modules are utilized as data structures to hold a complete description of the finite element model and the solution procedure to be applied to the model. VfeTools and VfsTools modules are used to implement the element formulations, material models and numerical analysis procedures used to create the superelement mass and stiffness matrices. The example includes support for solid, shell, beam and rigid type elements even though only shell and rigid elements are explicitly created.

The main program creates a slender cylindrical shell section spanning a 90 degree arc. Two off-section attachment points are created at either end of the shell section at the center of curvature. The attachment point at one end is linked to the shell nodes at the corresponding end using NASTRAN RBE2 like constraints. The attachment point at the other end is linked to the corresponding end using a NASTRAN RBE3 like constraint. The model geometry including element, material and solution properties are entered into the appropriate VisTools modules and registered with a single Model object.

A structure, FlexBody, is introduced which contains all instances of VfeTools modules required to support the finite element calculations of the element types, material models, etc. contained in the Model object. The FlexBodyInit function traverses the input Model object and initializes the FlexBody structure with the appropriate VfeTools objects. This FlexBody is passed to all subsequent functions to perform the degree of freedom table generation, FlexBodyDof, the flexible body mass and stiffness computations, FlexBodyGen, and various stress computations FlexBodyStr and FlexBodyStrElem. Finally all instances of VfeTools objects in FlexBody are destroyed using FlexBodyTerm.

The FlexBodyGen function performs the actual superelement mass and stiffness calculation. VfsTools objects are instanced for the required full system stiffness and mass matrices and temporary vectors. The solution procedure contained in the SProp object must be stored as solution sequence 1 in the solution property List object. The FlexBodyGen function only supports superelement creation, SYS_SOL_SUPERELEMENT.

The FlexBodyStr function illustrates stress computation for a system vector of displacements. In the example, two different uses of the FlexBodyStr function are illustrated. First an example set of generalized displacements are generated and expanded to the full system using vfs_SysVectorExpand(). The stress results associated with this displacement vector are then computed and printed. Second the stresses associated with each component mode are computed.

The FlexBodyStr function consists of a loop over all elements in the model. The displacements for each element are gathered from the full system solution vector and the element node stresses and strains are computed. For shell and beam elements, stress resultants (forces and moments) are computed. Stress at the shell midsurface and beam centroid are computed by dividing the stress resultants by the shell thickness and beam area respectively. These stress quantities are then transformed to global coordinates by querying the elements for the direction cosine matrices at each element node of the coordinate axes in which the stresses are expressed. The element node stresses in global coordinates are then entered into an element node State object. When all element stresses have been computed, the stresses are processed to yield a unique stress tensor at each node point using vis_StateMap().

The FlexBodyStrElem function illustrates computing the stress matrix which relates a set of generalized coordinates for a superelement to the element node stresses for a specific element, in this case for element number 1. The procedure is similar to the stress computation procedure in function FlexBodyStr. A loop is entered over each superelement component mode. The displacements from each mode are gathered and the component stresses and strains are computed and form a column of the stress-displacement matrix.

../../_images/vfetools-exam20.gif

Figure 20-1, Stress Contour on Deflected Shape of Mode 5

#include <stdlib.h>
#include <math.h>
#include "base/base.h"
#include "vis/vis.h"
#include "vis/vismesh.h"
#include "vfs/vfs.h"
#include "vfe/vfe.h"

static Vint itwos[6] = {2,2,2,2,2,2};

typedef struct FlexBody {
   vfe_Solid3D *solid3d;
   vfe_Shell3D *shell3d;
   vfe_Beam3D  *beam3d;
   vfe_MPC     *mpc;

   vsy_HashTable *matlfunh;

   vfe_ShellProp *shellprop;
   vfe_MatlFun   *matlfunshell;
   vfe_BeamProp  *beamprop;
   vfe_MatlFun   *matlfunbeam;

   Vdouble thickness[9];
   Vdouble area[3], iyy[3], izz[3], iyz[3], jtr[3];
} FlexBody;

static Vint
FlexBodyInit(FlexBody *fb, vis_Model *model, Vint verbose);
static void
FlexBodyTerm(FlexBody *fb);
static Vint
FlexBodyDof(FlexBody *fb, vis_Model *model, vfs_DofTab *doftab, Vint verbose);
static Vint
FlexBodyGen(FlexBody *fb, vis_Model *model, vfs_DofTab *doftab, 
            vfs_SysMatrix *redM, vfs_SysMatrix *redK,
            vfs_SysVector ***modes, vfs_SysVector *nodalMass,
            Vint *pNumModes, Vint *pNrd, Vint verbose);
static void
FlexBodyStr(FlexBody *fb, vis_Model *model, vfs_DofTab *doftab, 
            vfs_SysVector *sysV, vis_State *statent, Vint verbose);
static void
FlexBodyStrElem(FlexBody *fb, vis_Model *model, vfs_DofTab *doftab, 
                vfs_SysVector ***modes,
                Vint Nrd, Vint nelement, Vdouble sm[], Vint verbose);

static void
transStress3D(Vdouble tm[3][3], Vdouble t[6][6]);
static void
matvecprod6(Vdouble t[6][6], Vdouble a[6], Vdouble b[6]);

/*----------------------------------------------------------------------
                      Generate Flexible Body Using Component Mode Synthesis
----------------------------------------------------------------------*/
int
main()
{
                   /* FlexBody object */ 
   FlexBody fb;
                   /* Modelling objects */
   vis_MapMesh   *mapmesh;
   vis_Model     *model;
   vis_RCase     *rcase;
   vis_EProp     *eprop;
   vis_MProp     *mprop;
   vis_SProp     *sprop;
   vis_Connect   *connect;
   vsy_HashTable *mproph, *eproph, *rcaseh;
   vsy_List      *spropl;

                   /* Solution objects */ 
   vfs_DofTab    *doftab;
   vfs_SysMatrix *redK, *redM;
   vfs_SysVector **modes, *nodalMass;
                   /* Reduced solution vector */ 
   vfs_SysVector *redV;
                   /* Full solution vector */ 
   vfs_SysVector *sysV;

                   /* Result objects */
   vis_State *stated, *statent;
   vis_RProp *rprop;

                   /* geometry parameters */
   Vdouble radius = 10.;
   Vdouble theta  = 90.;
   Vdouble width  = 125.;
   Vdouble thick  = 2.;

                   /* material properties */ 
   Vdouble young   = 210000.;
   Vdouble poisson = 0.3;
   Vdouble density = 7.5e-09;

   Vint nelemcurve =  8;
   Vint nelemwidth = 40;
   
                   /* number of component modes requested */ 
   Vint nummodes = 10;
   Vint Nrd, NumModes;
   Vint neq, nre;
   Vint verbose = 1;

                   /* set patch point connectivity */
   Vint pix[8] = {1,2,3,4,5,6,7,8};

                   /* other parameters */
   Vint i, m, n;
   Vint tags[6] = {
      SYS_DOF_TX, SYS_DOF_TY, SYS_DOF_TZ,
      SYS_DOF_RX, SYS_DOF_RY, SYS_DOF_RZ };
   Vdouble rbe2center[3];
   Vdouble rbe3center[3];
   Vint rbe2node;
   Vint rbe3node;
   Vdouble coords[8][3];
   Vdouble dtheta;
   Vint numnp, numel, nedge, aid;
   Vint *ix;
   Vdouble val;
   Vdouble *sm;
   Vdouble u[VFE_MAXDOF];
   Vint lm[VFE_MAXDOF];
   Vint writeunvflag = 1;
   Vdouble dzero = 0.;

   dtheta = theta*(3.14159265/180.)/3.;

                   /* generate 4 points at each end of cylinder patch */
   for(i = 0; i < 4; i++) {
      coords[i][0] = radius*(1.-cos(dtheta*i));
      coords[i][1] = radius*sin(dtheta*i);
      coords[i][2] = 0.;

      coords[i+4][0] = coords[i][0];
      coords[i+4][1] = coords[i][1];
      coords[i+4][2] = -width;
   }
                   /* create MapMesh object */
   mapmesh = vis_MapMeshBegin ();
   vis_MapMeshDef (mapmesh,8,1);

                   /* create Connect object */
   connect = vis_ConnectBegin ();
   vis_ConnectPre (connect,SYS_DOUBLE);
   vis_ConnectDef (connect,0,0);

                   /* define points */ 
   for(i = 0; i < 8; i++) {
      vis_MapMeshSetPoint (mapmesh,i+1,coords[i]);
   }
                   /* define patch connectivity */ 
   vis_MapMeshSetParami (mapmesh,VIS_MESH_MAXI,2);
   vis_MapMeshSetPatch (mapmesh,1,VIS_SHAPEQUAD,4,2,0,pix);
   vis_MapMeshSetPatchParami (mapmesh,1,VIS_MESH_SHAPE,VIS_SHAPEQUAD);
   vis_MapMeshSetPatchParami (mapmesh,1,MAPMESH_NUMELEMI,nelemcurve);
   vis_MapMeshSetPatchParami (mapmesh,1,MAPMESH_NUMELEMJ,nelemwidth);

                   /* set assoc of 100 at z=0 and 200 at z=-width */ 
                   /* use these to identify RBE connections */
   vis_MapMeshSetPatchAssoc (mapmesh,VIS_MISCID,1,SYS_EDGE,1,100);
   vis_MapMeshSetPatchAssoc (mapmesh,VIS_MISCID,1,SYS_EDGE,3,200);

                   /* generate shell mesh */
   vis_MapMeshGenerate (mapmesh,connect);
                   /* delete MapMesh objects */ 
   vis_MapMeshEnd (mapmesh);

                   /* extract number of nodes and elements in shell */ 
   vis_ConnectNumber (connect,SYS_NODE,&numnp);
   vis_ConnectNumber (connect,SYS_ELEM,&numel);
   printf("Number of shell nodes    = %5d\n",numnp);
   printf("Number of shell elements = %5d\n",numel);

                   /* set useful shell element associations and property id */ 
   for(n = 1; n <= numel; n++) {
      vis_ConnectSetElemAssoc (connect,VIS_FEATYPE,n,SYS_ELEM_SHELL);
      vis_ConnectSetElemAssoc (connect,VIS_FEATECH,n,SYS_TECH_ANS);
      vis_ConnectSetElemAssoc (connect,VIS_PROPID,n,1);
   }

                   /* add center nodes for attachment points */
   rbe2center[0] = coords[3][0];
   rbe2center[1] = 0.;
   rbe2center[2] = coords[3][2];
   numnp += 1;
   rbe2node = numnp;
   vis_ConnectSetCoordsdv (connect,rbe2node,rbe2center);
   rbe3center[0] = coords[7][0];
   rbe3center[1] = 0.;
   rbe3center[2] = coords[7][2];
   numnp += 1;
   rbe3node = numnp;
   vis_ConnectSetCoordsdv (connect,rbe3node,rbe3center);

                   /* count number of nodes on edge */
   nedge = 0;
   for(i = 1; i <= numnp; i++) {
      vis_ConnectNodeAssoc (connect,VIS_MISCID,1,&i,&aid);
      if(aid == 100) {
        nedge++;
      }
   }
   ix = (Vint*)malloc((nedge+1)*sizeof(Vint));

                   /* add rbe2 as multiple elements */
   ix[0] = rbe2node;
   for(i = 1; i <= numnp; i++) {
      vis_ConnectNodeAssoc (connect,VIS_MISCID,1,&i,&aid);
      if(aid == 100) {
         ix[1] = i;
         numel += 1;
         vis_ConnectSetTopology (connect,numel,SYS_SHAPEPOINT,2,0,0);
         vis_ConnectSetElemNode (connect,numel,ix);
         vis_ConnectSetElemAssoc (connect,VIS_PROPID,numel,2);
         vis_ConnectSetElemAssoc (connect,VIS_FEATYPE,numel,SYS_ELEM_RIGID);
         vis_ConnectSetElemAssoc (connect,VIS_FEASPEC,numel,MPC_KINE);
      }
   }

                   /* add rbe3 as a single element */
   ix[0] = rbe3node;
   m = 0;
   for(i = 1; i <= numnp; i++) {
      vis_ConnectNodeAssoc (connect,VIS_MISCID,1,&i,&aid);
      if(aid == 200) {
         m++;
         ix[m] = i;
      }
   }
   numel += 1;
   vis_ConnectSetTopology (connect,numel,SYS_SHAPEPOINT,nedge+1,0,0);
   vis_ConnectSetElemNode (connect,numel,ix);
   vis_ConnectSetElemAssoc (connect,VIS_PROPID,numel,3);
   vis_ConnectSetElemAssoc (connect,VIS_FEATYPE,numel,SYS_ELEM_RIGID);
   vis_ConnectSetElemAssoc (connect,VIS_FEASPEC,numel,MPC_DIST);
   free(ix);

                   /* finite element nodes and elements complete */
   printf("Total number of nodes    = %5d\n",numnp);
   printf("Total number of elements = %5d\n",numel);

                   /* write SDRC Universal file of basic model */ 
   if(writeunvflag) {
      vis_ConnectWrite (connect,SYS_SDRC_UNIVERSAL,"exam20dev.unv");
   }

                   /* hash table of restraint cases */ 
   rcaseh = vsy_HashTableBegin();
   vsy_HashTableDef (rcaseh,10);

                   /* Suppress freedoms at rbe nodes */
   rcase = vis_RCaseBegin();
   for(i = 0; i < 6; i++) {
      vis_RCaseSetSPCdv (rcase,rbe2node,tags[i],RCASE_APPLIED,&dzero,0);
      vis_RCaseSetSPCdv (rcase,rbe3node,tags[i],RCASE_APPLIED,&dzero,0);
   }
   vsy_HashTableInsert (rcaseh,1,rcase);

                   /* hash table of element properties */ 
   eproph = vsy_HashTableBegin();
   vsy_HashTableDef (eproph,10);

                   /* shell element properties */ 
   eprop = vis_EPropBegin();
   vis_EPropDef (eprop,SYS_ELEM_SHELL);
   vis_EPropSetValued (eprop,EPROP_THICKNESS,thick);
   vis_EPropSetValuei (eprop,EPROP_MID,1);
   vsy_HashTableInsert (eproph,1,eprop);

                   /* rigid element properties */ 
   eprop = vis_EPropBegin();
   vis_EPropDef (eprop,SYS_ELEM_RIGID);
   vis_EPropSetValued (eprop,EPROP_PENALTY,1.e+9);
   vis_EPropSetValuei (eprop,EPROP_NUMDIST,nedge);
   vsy_HashTableInsert (eproph,2,eprop);

   eprop = vis_EPropBegin();
   vis_EPropDef (eprop,SYS_ELEM_RIGID);
   vis_EPropSetValued (eprop,EPROP_PENALTY,1.e+9);
   vis_EPropSetValuei (eprop,EPROP_NUMDIST,nedge);
   vsy_HashTableInsert (eproph,3,eprop);

                   /* hash table of material properties */ 
   mproph = vsy_HashTableBegin();
   vsy_HashTableDef (mproph,10);

                   /* isotropic material properties */ 
   mprop = vis_MPropBegin();
   vis_MPropDef (mprop,SYS_MAT_ISOTROPIC);
   vis_MPropSetValued (mprop,MPROP_DENSITY,density);
   vis_MPropSetValued (mprop,MPROP_E,young);
   vis_MPropSetValued (mprop,MPROP_NU,poisson);
   vsy_HashTableInsert (mproph,1,mprop);

                   /* list of solution properties */ 
   spropl = vsy_ListBegin();
   vsy_ListDef (spropl,10);

                   /* solution properties for superelement generation */ 
   sprop = vis_SPropBegin();
   vis_SPropDef (sprop,SYS_SOL_SUPERELEMENT);
   vis_SPropSetValuei (sprop,SPROP_EIGEN_NUM,nummodes);
   vis_SPropSetValuei (sprop,SPROP_RCASE,1);
   vis_SPropSetValuei (sprop,SPROP_MASSDIAG,SYS_ON);
   vsy_ListInsert (spropl,1,(Vobject*)sprop);

                   /* load Model object */ 
   model = vis_ModelBegin();
   vis_ModelSetObject (model,VIS_CONNECT,connect);
   vis_ModelSetHashTable (model,VIS_EPROP,eproph);
   vis_ModelSetHashTable (model,VIS_MPROP,mproph);
   vis_ModelSetHashTable (model,VIS_RCASE,rcaseh);
   vis_ModelSetList (model,VIS_SPROP,spropl);

                   /* instance solver objects */ 
   doftab    = vfs_DofTabBegin();
   nodalMass = vfs_SysVectorBegin();
   redM      = vfs_SysMatrixBegin();
   redK      = vfs_SysMatrixBegin();

                   /* initialize VfeTools filters */ 
   FlexBodyInit (&fb,model,verbose);

                   /* form degree of freedom table */ 
   FlexBodyDof (&fb,model,doftab,verbose);

                   /* generate flexible body */ 
   FlexBodyGen (&fb,model,doftab,redM,redK,&modes,nodalMass,
                &NumModes,&Nrd,verbose);

                   /* instance solution vector and fill with some numbers */ 
   redV = vfs_SysVectorBegin ();
   vfs_SysVectorDef (redV,Nrd);
   for(i = 0; i < Nrd; ++i) {
      val = .001*(i+1);
      vfs_SysVectorScatter (redV,1,&i,&val);
   }

                   /* instance result objects */ 
   vfs_DofTabProcess (doftab,&neq,&nre);
   sysV = vfs_SysVectorBegin ();
   vfs_SysVectorDef (sysV,neq);

                   /* expand to full system */
   vfs_SysVectorExpand (redV,Nrd,modes,sysV);

                   /* load node translations and rotations in state object */
   stated = vis_StateBegin();
   vis_StateDef (stated,numnp,SYS_NODE,SYS_NONE,VIS_SIXDOF);
   for(n = 1; n <= numnp; n++) {
      vfs_DofTabNodeDof (doftab,n,6,tags,lm);
      vfs_SysVectorGather (sysV,6,lm,u);
      vis_StateSetDatadv (stated,n,u);
   }
                   /* compute stress */ 
   statent = vis_StateBegin();
   vis_StateDef (statent,numnp,SYS_NODE,SYS_NONE,VIS_TENSOR);
   FlexBodyStr (&fb,model,doftab,sysV,statent,verbose);

                   /* compute mode stress shapes */ 
   if(verbose) printf("Begin computing stress modes\n");
   for(i = 0; i < Nrd; ++i) {
      vis_StateClear (stated);
      for(n = 1; n <= numnp; n++) {
         vfs_DofTabNodeDof (doftab,n,6,tags,lm);
         vfs_SysVectorGather (modes[i],6,lm,u);
         vis_StateSetDatadv (stated,n,u);
      }
      vis_StateClear (statent);
      if(verbose) printf("  Computing mode= %d\n",i+1);
      FlexBodyStr (&fb,model,doftab,modes[i],statent,0);
                   /* write SDRC Universal file of displacement and stress */ 
      if(writeunvflag) {
         rprop = vis_RPropBegin();
         vis_RPropDef (rprop,SYS_NODE,SYS_NONE);
         vis_RPropSetIds (rprop,i+1,0,0);
         vis_RPropSetType (rprop,SYS_RES_D);
         vis_StateWrite (stated,rprop,SYS_SDRC_UNIVERSAL,"exam20dev.unv");
         vis_RPropSetType (rprop,SYS_RES_S);
         vis_StateWrite (statent,rprop,SYS_SDRC_UNIVERSAL,"exam20dev.unv");
         vis_RPropEnd (rprop);
      }
   }
   if(verbose) printf("done!\n");

                   /* compute stress matrix for element number 1 */ 
   n = 1;
   sm = (Vdouble*)malloc(8*27*Nrd*sizeof(Vdouble));
   FlexBodyStrElem (&fb,model,doftab,&modes,Nrd,n,sm,verbose);
   free(sm);

                   /* terminate VfeTools filters */ 
   FlexBodyTerm (&fb);

                   /* delete solution vectors */
   vfs_SysVectorEnd (redV);
   vfs_SysVectorEnd (sysV);

                   /* delete result objects */ 
   vis_StateEnd (stated);
   vis_StateEnd (statent);

                   /* delete solver objects */ 
   for(i = 0; i < Nrd; ++i) {
      vfs_SysVectorEnd(modes[i]);
   }
   free(modes);
   vfs_SysMatrixEnd (redK);
   vfs_SysMatrixEnd (redM);
   vfs_SysVectorEnd (nodalMass);
   vfs_DofTabEnd    (doftab);

                   /* delete model objects */ 
   vsy_HashTableForEach (rcaseh,(void(*)(Vobject*))vis_RCaseEnd);
   vsy_HashTableForEach (eproph,(void(*)(Vobject*))vis_EPropEnd);
   vsy_HashTableForEach (mproph,(void(*)(Vobject*))vis_MPropEnd);
   vsy_ListForEach (spropl,(void(*)(Vobject*))vis_SPropEnd);
   vsy_HashTableEnd (mproph);
   vsy_HashTableEnd (eproph);
   vsy_HashTableEnd (rcaseh);
   vsy_ListEnd (spropl);
   vis_ConnectEnd (connect);
   vis_ModelEnd   (model);
   return 0;
}

/*----------------------------------------------------------------------
                      Initialize VfeTools objects
----------------------------------------------------------------------*/
static Vint
FlexBodyInit(FlexBody *fb, vis_Model *model, Vint verbose)
{
   Vint i;
   Vdouble shellprops[2] = {1., 5./6.};
   Vdouble beamprops[10] = {1., 1., 1., 1., 1., 5./6., 5./6., 0., 0., 0.};
   vsy_HashTable *mproph;
   Vint nprops;
   vis_MProp *mprop;
   Vint mtype, mid;
   vfe_LinMat *linmat;
   vfe_MatlFun *matlfun;
   Vint ntypes, mattype[MPROP_MAX];
   Vint densityflag, youngflag, poissonflag;
   Vdouble density, young, poisson, elasprop[2];

                   /* instance element formulations */ 
   fb->solid3d = vfe_Solid3DBegin ();
   fb->shell3d = vfe_Shell3DBegin ();
   fb->beam3d  = vfe_Beam3DBegin ();
   fb->mpc     = vfe_MPCBegin ();

                   /* shell properties */
   fb->shellprop = vfe_ShellPropBegin ();
   vfe_ShellPropDef (fb->shellprop,SHELLPROP_MONOCOQUE);
   vfe_ShellPropSetMonocoque (fb->shellprop,shellprops,2,SYS_RULE_GAUSS,0.,1);
   fb->matlfunshell = vfe_MatlFunBegin ();
   vfe_ShellPropMatlFun (fb->shellprop,fb->matlfunshell);
   vfe_Shell3DSetObject (fb->shell3d,VFE_MATLFUN,fb->matlfunshell);

                   /* shell thickness */
   vfe_Shell3DSetPropPtr (fb->shell3d,VFE_PROP_THICKNESS,fb->thickness);

                   /* beam properties */
   fb->beamprop  = vfe_BeamPropBegin ();
   vfe_BeamPropDef (fb->beamprop,BEAMPROP_SECTION);
   vfe_BeamPropSetSection (fb->beamprop,beamprops,1);
   fb->matlfunbeam  = vfe_MatlFunBegin ();
   vfe_BeamPropMatlFun (fb->beamprop,fb->matlfunbeam);
   vfe_Beam3DSetObject (fb->beam3d,VFE_MATLFUN,fb->matlfunbeam);

                   /* beam sections */
   vfe_Beam3DSetPropPtr (fb->beam3d,VFE_PROP_AREA,fb->area);
   vfe_Beam3DSetPropPtr (fb->beam3d,VFE_PROP_IYY,fb->iyy);
   vfe_Beam3DSetPropPtr (fb->beam3d,VFE_PROP_IZZ,fb->izz);
   vfe_Beam3DSetPropPtr (fb->beam3d,VFE_PROP_IYZ,fb->iyz);
   vfe_Beam3DSetPropPtr (fb->beam3d,VFE_PROP_J,fb->jtr);

                   /* extract material property hash table */
   vis_ModelGetHashTable (model,VIS_MPROP,&mproph);
   if(!mproph) {
      if(verbose) printf("No material properties in model\n");
      return 1;
   }
                   /* create hashtable of material interfaces */ 
   fb->matlfunh = vsy_HashTableBegin ();
   vsy_HashTableCount (mproph,&nprops);
   vsy_HashTableDef (fb->matlfunh,nprops);

                   /* loop through material properties */
   vsy_HashTableInitIter (mproph);
   while(vsy_HashTableNextIter (mproph,&mid,(Vobject**)&mprop),mprop) {
      vis_MPropInq (mprop,&mtype);
                   /* only isotropic, non temperature dependent materials */
      if(mtype == SYS_MAT_ISOTROPIC) {
         linmat = vfe_LinMatBegin ();
         vfe_LinMatDef (linmat,SYS_MAT_ISOTROPIC);
         vis_MPropValueType (mprop,&ntypes,mattype);
         densityflag = youngflag = poissonflag = 0;
         for(i = 0; i < ntypes; i++) {
            if(mattype[i] == MPROP_DENSITY) {
               vis_MPropValueDouble (mprop,MPROP_DENSITY,&density);
               densityflag = 1;
            } else if(mattype[i] == MPROP_E) {
               vis_MPropValueDouble (mprop,MPROP_E,&young);
               youngflag = 1;
            } else if(mattype[i] == MPROP_NU) {
               vis_MPropValueDouble (mprop,MPROP_NU,&poisson);
               poissonflag = 1;
            }
         }
         if(densityflag) {
            vfe_LinMatSetDensity (linmat,density);
         }
                   /* Both Young's modulus and Poisson's ratio */
         if(youngflag && poissonflag) {
            elasprop[0] = young;
            elasprop[1] = poisson;
            vfe_LinMatSetElasProp (linmat,elasprop);
         }
         matlfun = vfe_MatlFunBegin ();
         vfe_LinMatMatlFun (linmat,matlfun);
      }
      vsy_HashTableInsert (fb->matlfunh,mid,matlfun);
   }
   return 0;
}

/*----------------------------------------------------------------------
                      Terminate VfeTools objects
----------------------------------------------------------------------*/
static void
FlexBodyTerm(FlexBody *fb)
{
   Vint mid;
   vfe_LinMat *linmat;
   vfe_MatlFun *matlfun;

                   /* free material functions */
   vsy_HashTableInitIter (fb->matlfunh);
   while(vsy_HashTableNextIter(fb->matlfunh,&mid,(Vobject**)&matlfun),matlfun) {
      vfe_MatlFunGetObj (matlfun,(Vobject**)&linmat);
      vfe_LinMatEnd (linmat);
   }
   vsy_HashTableForEach (fb->matlfunh,(void(*)(Vobject*))vfe_MatlFunEnd);
   vsy_HashTableEnd (fb->matlfunh);

   vfe_MatlFunEnd (fb->matlfunbeam);
   vfe_MatlFunEnd (fb->matlfunshell);

   vfe_BeamPropEnd (fb->beamprop);
   vfe_ShellPropEnd (fb->shellprop);
   vfe_MPCEnd (fb->mpc);
   vfe_Beam3DEnd (fb->beam3d);
   vfe_Shell3DEnd (fb->shell3d);
   vfe_Solid3DEnd (fb->solid3d);
}

/*----------------------------------------------------------------------
                      Generate Degree of freedom table
----------------------------------------------------------------------*/
static Vint
FlexBodyDof(FlexBody *fb, vis_Model *model, vfs_DofTab *doftab, Vint verbose)
{
                   /* localized FlexBody objects */
   vfe_Solid3D *solid3d;
   vfe_Shell3D *shell3d;
   vfe_Beam3D  *beam3d;
   vfe_MPC     *mpc;
                   /* VisTools objects */
   vis_Connect *connect;
   vis_RCase *rcase;
   vis_SProp *sprop;
                   /* Base objects */
   vsy_HashTable *rcaseh;
   vsy_List      *spropl;

   Vint i, n;
   Vint tags[6] = {
      SYS_DOF_TX, SYS_DOF_TY, SYS_DOF_TZ,
      SYS_DOF_RX, SYS_DOF_RY, SYS_DOF_RZ };
   Vint locone[6] = {1,1,1,1,1,1};
   Vint numel, numnp;
   Vint shape, maxi, maxj, maxk;
   Vint featype, feaspec, featech;
   Vint maxnedofs, nedofs, *loc, *tag, ntags;
   Vint nix, maxnix, *ix;
   Vint rcaseid;
   Vint constrtype, constrmaster;
   Vdouble constrval;
   Vint neq, nre;

   if(verbose) printf("Begin formation of global dof table\n");

                   /* extract number of nodes and elements */
   vis_ModelGetObject (model,VIS_CONNECT,(Vobject**)&connect);
   vis_ConnectNumber (connect,SYS_ELEM,&numel);
   vis_ConnectNumber (connect,SYS_NODE,&numnp);

                   /* localize VfeTools objects */
   solid3d = fb->solid3d;
   shell3d = fb->shell3d;
   beam3d  = fb->beam3d;
   mpc     = fb->mpc;

                   /* allocate arrays with maximum number of element nodes */
   vis_ConnectMaxElemNode (connect,&maxnix);
   ix = (Vint*)malloc(maxnix*sizeof(Vint));

                   /* maximum size of non-MPC element */
   maxnedofs = VFE_MAXDOF;
   loc = (Vint*)malloc(VFE_MAXDOF*sizeof(Vint));
   tag = (Vint*)malloc(VFE_MAXDOF*sizeof(Vint));

                   /* prepare DofTab object */
   vfs_DofTabDef (doftab,numnp,numel);

                   /* loop over all elements to declare element use */
   for(n = 1; n <= numel; n++) {
      vis_ConnectTopology (connect,n,&shape,&maxi,&maxj,&maxk);
      vis_ConnectElemNode (connect,n,&nix,ix);
      vis_ConnectElemAssoc (connect,VIS_FEATYPE,1,&n,&featype);
      vis_ConnectElemAssoc (connect,VIS_FEATECH,1,&n,&featech);
      vis_ConnectElemAssoc (connect,VIS_FEASPEC,1,&n,&feaspec);
      if(featype == SYS_ELEM_SOLID) {
         vfe_Solid3DSetTopology (solid3d,shape,maxi,maxj,maxk);
         vfe_Solid3DSetParami (solid3d,VFE_TECH,featech);
         vfe_Solid3DNumDof (solid3d,VFE_ANALYSIS_STRUCTURAL,&nedofs);
         vfe_Solid3DDofMap (solid3d,VFE_ANALYSIS_STRUCTURAL,loc,tag);
      } else if(featype == SYS_ELEM_SHELL) {
         vfe_Shell3DSetTopology (shell3d,shape,maxi,maxj);
         vfe_Shell3DSetParami (shell3d,VFE_TECH,featech);
         vfe_Shell3DNumDof (shell3d,VFE_ANALYSIS_STRUCTURAL,&nedofs);
         vfe_Shell3DDofMap (shell3d,VFE_ANALYSIS_STRUCTURAL,loc,tag);
      } else if(featype == SYS_ELEM_BEAM) {
         vfe_Beam3DSetTopology (beam3d,maxi);
         vfe_Beam3DSetParami (beam3d,VFE_TECH,featech);
         vfe_Beam3DNumDof (beam3d,VFE_ANALYSIS_STRUCTURAL,&nedofs);
         vfe_Beam3DDofMap (beam3d,VFE_ANALYSIS_STRUCTURAL,loc,tag);
      } else if(featype == SYS_ELEM_RIGID) {
         vfe_MPCDef (mpc,feaspec);
                   /* RBE3 style */
         if(feaspec == MPC_DIST) {
            vfe_MPCSetDist (mpc,MPC_DIST_3D,nix-1,SYS_OFF,NULL);
                   /* RBE2 style */
         } else if(feaspec == MPC_KINE) {
            vfe_MPCSetKine (mpc,locone,tags,6,itwos,tags);
         }
         vfe_MPCNumDof(mpc,VFE_ANALYSIS_STRUCTURAL,&nedofs);
                   /* large MPCs may need to increase storage */
         if(nedofs > maxnedofs) {
            loc = (Vint*)realloc(loc,nedofs*sizeof(Vint));
            tag = (Vint*)realloc(tag,nedofs*sizeof(Vint));
            maxnedofs = nedofs;
         }
         vfe_MPCDofMap (mpc,VFE_ANALYSIS_STRUCTURAL,loc,tag);
      }
      vfs_DofTabSetMap (doftab,nedofs,loc,tag);
      vfs_DofTabElemUse (doftab,n,nix,ix);
   }
                   /* Check for permanent node restraints */
   vis_ModelGetList (model,VIS_SPROP,&spropl);
   vsy_ListRef (spropl,1,(Vobject**)&sprop);
   vis_SPropValueInteger (sprop,SPROP_RCASE,&rcaseid);
   vis_ModelGetHashTable (model,VIS_RCASE,&rcaseh);
   vsy_HashTableLookup (rcaseh,rcaseid,(Vobject**)&rcase);

   for(n = 1; n <= numnp; n++) {
      vis_RCaseSPCTag (rcase,n,&ntags,tag);
      for(i = 0; i < ntags; i++) {
         vis_RCaseSPCdv (rcase,n,tag[i],&constrtype,&constrval,&constrmaster);
         if(constrtype == RCASE_FIXED) {
            vfs_DofTabNodePerm (doftab,n,1,&tag[i]);
         }
      }
   }
                   /* finalize equation count */
   vfs_DofTabProcess (doftab,&neq,&nre);
   if(verbose) {
      printf("Number of equations = %d\n",neq);
      if(neq == 0) {
         printf("No equations\n");
         return 1;
      }
   }
                   /* free memory */ 
   free(ix);
   free(loc);
   free(tag);
   if(verbose) printf("done!\n");
   return 0;
}

/*----------------------------------------------------------------------
                      Generate flexible body
----------------------------------------------------------------------*/
static Vint
FlexBodyGen(FlexBody *fb, vis_Model *model, vfs_DofTab *doftab, 
            vfs_SysMatrix *redM, vfs_SysMatrix *redK,
            vfs_SysVector ***modes, vfs_SysVector *nodalMass,
            Vint *pNumModes, Vint *pNrd, Vint verbose)
{
                   /* localized FlexBody objects */ 
   vfe_Solid3D *solid3d;
   vfe_Shell3D *shell3d;
   vfe_Beam3D  *beam3d;
   vfe_MPC     *mpc;
   vfe_ShellProp *shellprop;
   vfe_BeamProp  *beamprop;
   vsy_HashTable *matlfunh;

                   /* temporary instances */ 
   vfe_MatlFun *matlfun;

                   /* VfsTools objects */ 
   vfs_SysMatrix *sysk, *sysm;
   vfs_SysVector *temp, *rede, **redv;

                   /* VisTools objects */ 
   vis_Connect *connect;
   vis_RCase *rcase;
   vis_EProp *eprop;
   vis_SProp *sprop;

                   /* Base objects */ 
   vsy_HashTable *rcaseh;
   vsy_HashTable *eproph;
   vsy_List      *spropl;

                   /* auxiliary variables */
   Vint i, j, n;
   Vint tags[6] = {
      SYS_DOF_TX, SYS_DOF_TY, SYS_DOF_TZ,
      SYS_DOF_RX, SYS_DOF_RY, SYS_DOF_RZ };
   Vint locone[6] = {1,1,1,1,1,1};
   Vint dmFlag;
   Vint numel, numnp, numRests;
   Vint shape, maxi, maxj, maxk;
   Vint featype, feaspec, featech, massflag, pid, mid;
   Vint maxnedofs, nedofs, *loc, *tag, ntags;
   Vint nix, maxnix, *ix;

   Vint    wflag, ndist, numModes, rcaseid;
   Vint    stype;
   Vint    constrtype, constrmaster;
   Vint    neq, nre;
   Vdouble *weights;
   Vdouble constrval, penalty;
   Vdouble done = 1.;
   Vdouble *ke, *me, *mc, (*xl)[3];
   Vint    *lm, *lmrest;
   Vint    neigen, nrd;
   Vdouble *eigenval;
   Vdouble value;

                   /* Retrieve list of solution properties */ 
   vis_ModelGetList (model,VIS_SPROP,&spropl);
   if(spropl == NULL) {
      if(verbose) printf("No solution properties\n");
      return 1;
   }
                   /* assume first solution sequence */ 
   vsy_ListRef (spropl,1,(Vobject**)&sprop);
   if(sprop == NULL) {
      if(verbose) printf("No solution properties\n");
      return 1;
   }
                   /* get superelement solution properties */ 
   vis_SPropInq (sprop,&stype);
   if(stype == SYS_SOL_SUPERELEMENT) {
      dmFlag = 1;
      vis_SPropValueInteger (sprop,SPROP_MASSDIAG,&dmFlag);
      numModes = 1;
      vis_SPropValueInteger (sprop,SPROP_EIGEN_NUM,&numModes);
      rcaseid = 1;
      vis_SPropValueInteger (sprop,SPROP_RCASE,&rcaseid);
   } else {
      if(verbose) printf("Only superelement solution supported\n");
      return 1;
   }
                   /* extract number of nodes and elements */
   vis_ModelGetObject (model,VIS_CONNECT,(Vobject**)&connect);
   vis_ConnectNumber (connect,SYS_ELEM,&numel);
   vis_ConnectNumber (connect,SYS_NODE,&numnp);

                   /* localize VfeTools objects */ 
   solid3d = fb->solid3d;
   shell3d = fb->shell3d;
   beam3d  = fb->beam3d;
   mpc     = fb->mpc;
   shellprop = fb->shellprop;
   beamprop  = fb->beamprop;
   matlfunh  = fb->matlfunh;

                   /* extract element property hash table */ 
   vis_ModelGetHashTable (model,VIS_EPROP,&eproph);
   if(!eproph) {
      if(verbose) printf("No element properties in model\n");
      return 1;
   }
                   /* extract restraint case hash table */ 
   vis_ModelGetHashTable (model,VIS_RCASE,&rcaseh);
   if(!rcaseh) {
      if(verbose) printf("No restraint case in model\n");
      return 1;
   }
   vsy_HashTableLookup (rcaseh,rcaseid,(Vobject**)&rcase);
   if(rcase == NULL) {
      if(verbose) printf("RCase %d not found\n",rcaseid);
      return 1;
   }

                   /* allocate arrays with maximum number of element nodes */
   vis_ConnectMaxElemNode (connect,&maxnix);
   ix      = (Vint*)malloc(maxnix*sizeof(Vint));
   weights = (Vdouble*)malloc(maxnix*sizeof(Vdouble));

                   /* query for number of equations, reactions */ 
   vfs_DofTabProcess (doftab,&neq,&nre);

                   /* allocate arrays with maximum size element dof map */
   vfs_DofTabMaxElemDof (doftab,&maxnedofs);
   loc = (Vint*)malloc(maxnedofs*sizeof(Vint));
   tag = (Vint*)malloc(maxnedofs*sizeof(Vint));

                   /* Generate storage for largest element matrix */
   ke = (Vdouble*)malloc((maxnedofs*(maxnedofs+2)/2)*sizeof(Vdouble));
   me = (Vdouble*)malloc(maxnedofs*sizeof(Vdouble));
   mc = (Vdouble*)malloc((maxnedofs*(maxnedofs+2)/2)*sizeof(Vdouble));
   lm = (Vint*)malloc(maxnedofs*sizeof(Vint));
   xl = (Vdouble(*)[3])malloc(3*maxnix*sizeof(Vdouble));

                   /* form stiffness and mass */
   sysk = vfs_SysMatrixBegin ();
   vfs_SysMatrixDef (sysk,SYSMATRIX_SYMM_SPARSE,neq);

                   /* create either lumped or consistent mass object */ 
   sysm  = vfs_SysMatrixBegin();
   if(dmFlag) {
      vfs_SysMatrixDef (sysm,SYSMATRIX_DIAG,neq);
   } else {
      vfs_SysMatrixDef (sysm,SYSMATRIX_SYMM_SPARSE,neq);
   }
                   /* preprocess and initialize stiffness and mass */ 
   if(verbose) printf("Begin preprocessing stiffness and mass\n");
   vfs_SysMatrixSetObject (sysk,VFS_DOFTAB,(Vobject*)doftab);
   vfs_SysMatrixPreProcess (sysk);
   vfs_SysMatrixPreProcess (sysm);
   vfs_SysMatrixInit (sysk,0.);
   vfs_SysMatrixInit (sysm,0.);
   if(verbose) printf("done!\n");

                   /* perpare vector for nodal mass assembly */ 
   vfs_SysVectorDef (nodalMass,numnp);

                   /* form and assemble k and m */ 
   if(verbose) printf("Begin assembling stiffness and mass\n");
   vfs_SysMatrixInit (sysk,0.);
   vfs_SysMatrixInit (sysm,0.);
   for(n = 1; n <= numel; n++) {
      vis_ConnectTopology (connect,n,&shape,&maxi,&maxj,&maxk);
      vis_ConnectElemNode (connect,n,&nix,ix);
      vis_ConnectCoordsdv (connect,nix,ix,xl);
      vis_ConnectElemAssoc (connect,VIS_FEATYPE,1,&n,&featype);
      vis_ConnectElemAssoc (connect,VIS_FEATECH,1,&n,&featech);
      vis_ConnectElemAssoc (connect,VIS_FEASPEC,1,&n,&feaspec);
      vis_ConnectElemAssoc (connect,VIS_PROPID,1,&n,&pid);
      vsy_HashTableLookup (eproph,pid,(Vobject**)&eprop);

      massflag = 0;
      if(featype == SYS_ELEM_SOLID) {
         massflag = 1;
         vfe_Solid3DSetTopology (solid3d,shape,maxi,maxj,maxk);
         vfe_Solid3DSetParami (solid3d,VFE_TECH,featech);
         vfe_Solid3DNumDof (solid3d,VFE_ANALYSIS_STRUCTURAL,&nedofs);
         vfe_Solid3DDofMap (solid3d,VFE_ANALYSIS_STRUCTURAL,loc,tag);
         vis_EPropValueInteger (eprop,EPROP_MID,&mid);
         vsy_HashTableLookup (matlfunh,mid,(Vobject**)&matlfun);
         vfe_Solid3DSetObject (solid3d,VFE_MATLFUN,matlfun);
         vfe_Solid3DStiff (solid3d,xl,ke);
         if(!dmFlag) {
            vfe_Solid3DMass (solid3d,xl,mc);
         }
         vfe_Solid3DMassDiag (solid3d,xl,me);
      } else if(featype == SYS_ELEM_SHELL) {
         massflag = 1;
         vfe_Shell3DSetTopology (shell3d,shape,maxi,maxj);
         vfe_Shell3DSetParami (shell3d,VFE_TECH,featech);
         vfe_Shell3DNumDof (shell3d,VFE_ANALYSIS_STRUCTURAL,&nedofs);
         vfe_Shell3DDofMap (shell3d,VFE_ANALYSIS_STRUCTURAL,loc,tag);
         vsy_HashTableLookup (eproph,pid,(Vobject**)&eprop);
         vis_EPropValueInteger (eprop,EPROP_MID,&mid);
         vsy_HashTableLookup (matlfunh,mid,(Vobject**)&matlfun);
         vfe_ShellPropSetMatlFun (shellprop,1,matlfun);
         vis_EPropEvaldv (eprop,EPROP_THICKNESS,shape,maxi,maxj,fb->thickness);
         vfe_Shell3DStiff (shell3d,xl,ke);
         if(!dmFlag) {
            vfe_Shell3DMass (shell3d,xl,mc);
         }
         vfe_Shell3DMassDiag (shell3d,xl,me);
      } else if(featype == SYS_ELEM_BEAM) {
         massflag = 1;
         vfe_Beam3DSetTopology (beam3d,maxi);
         vfe_Beam3DSetParami (beam3d,VFE_TECH,featech);
         vfe_Beam3DNumDof (beam3d,VFE_ANALYSIS_STRUCTURAL,&nedofs);
         vfe_Beam3DDofMap (beam3d,VFE_ANALYSIS_STRUCTURAL,loc,tag);
         vsy_HashTableLookup (eproph,pid,(Vobject**)&eprop);
         vis_EPropValueInteger (eprop,EPROP_MID,&mid);
         vsy_HashTableLookup (matlfunh,mid,(Vobject**)&matlfun);
         vfe_BeamPropSetMatlFun (beamprop,1,matlfun);
         vis_EPropEvaldv (eprop,EPROP_AREA,shape,maxi,maxj,fb->area);
         vis_EPropEvaldv (eprop,EPROP_IYY, shape,maxi,maxj,fb->iyy);
         vis_EPropEvaldv (eprop,EPROP_IZZ, shape,maxi,maxj,fb->izz);
         vis_EPropEvaldv (eprop,EPROP_IYZ, shape,maxi,maxj,fb->iyz);
         vis_EPropEvaldv (eprop,EPROP_J,   shape,maxi,maxj,fb->jtr);
         vfe_Beam3DStiff (beam3d,xl,ke);
         if(!dmFlag) {
            vfe_Beam3DMass (beam3d,xl,mc);
         }
         vfe_Beam3DMassDiag (beam3d,xl,me);
      } else if(featype == SYS_ELEM_RIGID) {
         vfe_MPCDef (mpc,feaspec);
         if(feaspec == MPC_DIST) {
            vsy_HashTableLookup (eproph,pid,(Vobject**)&eprop);
            vis_EPropValueInteger (eprop,EPROP_NUMDIST,&ndist);
            vis_EPropValueFlag (eprop,EPROP_WEIGHTS,&wflag);
            if(wflag) {
               vis_EPropValueDouble (eprop,EPROP_WEIGHTS,weights);
               vfe_MPCSetDist (mpc,MPC_DIST_3D,ndist,wflag,weights);
            } else {
               vfe_MPCSetDist (mpc,MPC_DIST_3D,ndist,wflag,NULL);
            }
         } else if(feaspec == MPC_KINE) {
            vfe_MPCSetKine (mpc,locone,tags,6,itwos,tags);
         }
         vfe_MPCNumDof (mpc,VFE_ANALYSIS_STRUCTURAL,&nedofs);
         vfe_MPCDofMap (mpc,VFE_ANALYSIS_STRUCTURAL,loc,tag);
         vsy_HashTableLookup (eproph,pid,(Vobject**)&eprop);
         vis_EPropValueDouble (eprop,EPROP_PENALTY,&penalty);
         if(penalty != 0.) {
            vfe_MPCSetParamd (mpc,MPC_PENALTY,penalty);
         }
         vfe_MPCStiff (mpc,xl,ke);
      }
      vfs_DofTabElemDof (doftab,n,nix,ix,&nedofs,lm);
      vfs_SysMatrixAssem (sysk,nedofs,lm,ke);
      if(massflag) {
         if(dmFlag) {
            vfs_SysMatrixAssemDiag (sysm,nedofs,lm,me);
         } else {
            vfs_SysMatrixAssem (sysm,nedofs,lm,mc);
         }
         for(j = 0; j < nedofs; j++) {
            if(tag[j] == SYS_DOF_TX) {
               vfs_SysVectorAssem (nodalMass,1,&ix[loc[j]-1],&me[j]);
            }
         }
      }
   }
   if(verbose) printf("done!\n");

                   /* define attachment restraints */ 
                   /* count number of restraints */
   numRests = 0;
   for(n = 1; n <= numnp; n++) {
      vis_RCaseSPCTag (rcase,n,&ntags,tag);
      for(i = 0; i < ntags; i++) {
         vis_RCaseSPCdv (rcase,n,tag[i],&constrtype,&constrval,&constrmaster);
         if(constrtype == RCASE_APPLIED) {
            numRests++;
         }
      }
   }
   if(numRests == 0) {
      if(verbose) printf("No restraints defined\n");
      return 1;
   }
                   /* determine dof of restraints */ 
   lmrest = (Vint*)malloc(numRests*sizeof(Vint));
   numRests = 0;
   for(n = 1; n <= numnp; n++) {
      vis_RCaseSPCTag (rcase,n,&ntags,tag);
      for(i = 0; i < ntags; i++) {
         vis_RCaseSPCdv (rcase,n,tag[i],&constrtype,&constrval,&constrmaster);
         if(constrtype == RCASE_APPLIED) {
           vfs_DofTabNodeDof (doftab,n,1,&tag[i],&lmrest[numRests]);
           numRests++;
         }
      }
   }
                   /* form numRests force vectors due to unit displacements */ 
                   /* use modes vectors here to store the force vectors */
                   /* temp is a scratch vector */
   temp = vfs_SysVectorBegin();
   vfs_SysVectorDef (temp,neq);

                   /* a "1" is inserted at the unit displacement */ 
   *modes = (vfs_SysVector**)malloc((numModes+numRests)*sizeof(vfs_SysVector*));
   eigenval = (Vdouble*)malloc(numModes*sizeof(Vdouble));
   for(i = 0; i < numRests; i++) {
      vfs_SysVectorInit (temp,0.);
      vfs_SysVectorScatter (temp,1, &lmrest[i], &done);
      (*modes)[i] = vfs_SysVectorBegin();
      vfs_SysVectorDef ((*modes)[i],neq);
      vfs_SysMatrixProd (sysk,temp,(*modes)[i]);
      vfs_SysVectorScale ((*modes)[i],(*modes)[i], -done);
   }

                   /* set restraints as "temporary" */ 
   vfs_SysMatrixSetTemp (sysk, numRests, lmrest);

                   /* process and factorize */ 
   if(verbose) printf("Begin factorizing\n");
   vfs_SysMatrixProcess (sysk);
   vfs_SysMatrixFactor (sysk);
                   /* check for factorization problems */ 
   if(vfs_SysMatrixError(sysk) != 0) {
      if(verbose) printf("Factorization error encountered\n");
      return 1;
   }
   if(verbose) printf("done!\n");
                   
                   /* form numRests static modes */ 
                   /* a "1" is reinserted at the unit displacement */ 
   if(verbose) printf("Begin calculating static modes\n");
   for(i = 0; i < numRests; i++) {
      vfs_SysVectorMove (temp, (*modes)[i]);
      vfs_SysMatrixSolve (sysk, temp, (*modes)[i]);
      vfs_SysVectorScatter ((*modes)[i], 1, &lmrest[i], &done);
   }
   if(verbose) printf("done!\n");

                   /* form numModes vibration modes */ 
   if(verbose) printf("Begin calculating vibration modes\n");
   vfs_SysMatrixSetParami (sysk,SYSMATRIX_EIGEN,SYSMATRIX_EIGEN_VIBE);
   vfs_SysMatrixSetParami (sysk,SYSMATRIX_EIGEN_NUM,numModes);
   vfs_SysMatrixSetParami (sysk,SYSMATRIX_EIGEN_TYPE,SYS_EIGEN_NEAREST);

   vfs_SysMatrixEigen (sysk,sysm,&neigen,eigenval);
   if(verbose) printf("done!\n");

   if(verbose) {
      printf("Eigenvalues of full system\n");
      for(i = 0; i < neigen; i++) {
         printf("eigenvalue[%d]= %f\n",i+1,eigenval[i]);
      }
   }
                   /* Warning, reduce number of component modes */ 
   if(neigen != numModes) {
      if(verbose) {
         printf("Warning: number of eigenvalues less than requested\n");
      }
      numModes = neigen;
   }
   *pNumModes = numModes;

                   /* retrieve vibration modes */ 
   for(i = 0; i < numModes; i++) {
      (*modes)[numRests+i] = vfs_SysVectorBegin();
      vfs_SysVectorDef ((*modes)[numRests+i],neq);
      vfs_SysMatrixEigenMode (sysk,i+1,(*modes)[numRests+i]);
   }
                   /* free up internal eigenvector storage */ 
   vfs_SysMatrixEigenFree (sysk);

                   /* the total number of dof in the reduced system */ 
   if(verbose) printf("Begin reduction\n");
   nrd = numRests + numModes;
   *pNrd = nrd;

                   /* turn off restraints */ 
   vfs_SysMatrixSetTemp (sysk,0,NULL);

                   /* create symmetric full matrices for reduced system */ 
                   /* create reduced stiffness */ 
                   /* Assuming redK already allocated & initialized */
   vfs_SysMatrixDef (redK,SYSMATRIX_SYMM_FULL,nrd);
   vfs_SysMatrixPreProcess (redK);
   vfs_SysMatrixReduce (sysk,nrd,numRests,numModes,lmrest,*modes,redK);

                   /* create reduced mass */ 
                   /* Assuming redM already allocated & initialized */
   vfs_SysMatrixDef (redM,SYSMATRIX_SYMM_FULL,nrd);
   vfs_SysMatrixPreProcess (redM);
   vfs_SysMatrixReduce (sysm,nrd,0,numModes,NULL,*modes,redM);
   if(verbose) printf("done!\n");

                   /* compute all eigenvalues of reduced system */
                   /* create reduced vector for eigenvalues */ 
   rede = vfs_SysVectorBegin();
   vfs_SysVectorDef (rede,nrd);

                   /* Create nrd reduced vectors for eigenvectors */ 
   redv = (vfs_SysVector**)malloc(nrd*sizeof(vfs_SysVector*));
   for(i = 0; i < nrd; i++) {
      redv[i] = vfs_SysVectorBegin();
      vfs_SysVectorDef (redv[i],nrd);
   }
   vfs_SysMatrixSetParami (redK, SYSMATRIX_EIGEN, SYSMATRIX_EIGEN_VIBE);
   vfs_SysMatrixEigenAll (redK, redM, rede, redv);

                   /* print eigenvalues */ 
   if(verbose) {
      printf("Eigenvalues of reduced system\n");
      for(i = 1; i <= nrd; i++) {
         vfs_SysVectorGather (rede,1,&i,&value);
         printf("eigenvalue[%d]= %e\n",i,value);
      }
   }
                   /* free objects */ 
   for(i = 0; i < nrd; i++) {
      vfs_SysVectorEnd (redv[i]);
   }
   free(redv);
   vfs_SysVectorEnd (rede);
   free(eigenval);
   vfs_SysVectorEnd (temp);
   free(lmrest);
   vfs_SysMatrixEnd (sysm);
   vfs_SysMatrixEnd (sysk);
   free(xl);
   free(lm);
   free(mc);
   free(me);
   free(ke);
   free(tag);
   free(loc);
   free(ix);
   free(weights);

   if(verbose) printf("Model solved\n");
   return 0;
}

/*----------------------------------------------------------------------
                      Compute stress
----------------------------------------------------------------------*/
static void
FlexBodyStr(FlexBody *fb, vis_Model *model, vfs_DofTab *doftab, 
            vfs_SysVector *sysV, vis_State *statent, Vint verbose)
{
                   /* localized FlexBody objects */
   vfe_Solid3D *solid3d;
   vfe_Shell3D *shell3d;
   vfe_Beam3D  *beam3d;
   vfe_ShellProp *shellprop;
   vfe_BeamProp  *beamprop;
   vsy_HashTable *matlfunh;

                   /* localized Model objects */
   vis_Connect *connect;
   vsy_HashTable *eproph;
   vfe_MatlFun *matlfun;
   vis_EProp *eprop;

                   /* temporary objects for stress mapping */ 
   vis_State *stateent;
   vis_GridFun *gridfun;

   Vint i, j, n;
   Vint numel, numnp;
   Vint shape, maxi, maxj, maxk;
   Vint featype, feaspec, featech, pid, mid;
   Vint nix, ix[27];
   Vdouble xl[27][3];
   Vint nedofs, loc[VFE_MAXDOF], tag[VFE_MAXDOF], lm[VFE_MAXDOF];
   Vdouble u[VFE_MAXDOF];
   Vdouble strs[27*8], strn[27*8];
   Vdouble lstrs[6], gstrs[9][6], tm[9][3][3], stm[6][6];
   Vdouble z,z2,t,t2,factor1,factor2;

                   /* prepare to compute stresses */
                   /* extract number of nodes and elements */
   vis_ModelGetObject (model,VIS_CONNECT,(Vobject**)&connect);
   vis_ConnectNumber (connect,SYS_ELEM,&numel);
   vis_ConnectNumber (connect,SYS_NODE,&numnp);

                   /* temporary objects for element node stress */ 
   gridfun = vis_GridFunBegin();
   vis_ConnectGridFun (connect,gridfun);
   stateent = vis_StateBegin();
   vis_StateDef (stateent,numel,SYS_ELEM,SYS_NODE,VIS_TENSOR);
   vis_StateSetObject (stateent,VIS_GRIDFUN,gridfun);

                   /* localize VfeTools objects */
   solid3d = fb->solid3d;
   shell3d = fb->shell3d;
   beam3d  = fb->beam3d;
   shellprop = fb->shellprop;
   beamprop  = fb->beamprop;
   matlfunh  = fb->matlfunh;

                   /* extract element property hash table */
   vis_ModelGetHashTable (model,VIS_EPROP,&eproph);

                   /* compute stresses */
   if(verbose) printf("Begin stress computation\n");
   for(n = 1; n <= numel; n++) {
      vis_ConnectElemAssoc (connect,VIS_FEATYPE,1,&n,&featype);
      if(featype == SYS_ELEM_RIGID) {
         continue;
      }
      if(verbose) {
         printf("element= %d\n",n);
      }
      vis_ConnectTopology (connect,n,&shape,&maxi,&maxj,&maxk);
      vis_ConnectElemNode (connect,n,&nix,ix);
      vis_ConnectCoordsdv (connect,nix,ix,xl);
      vis_ConnectElemAssoc (connect,VIS_FEATECH,1,&n,&featech);
      vis_ConnectElemAssoc (connect,VIS_FEASPEC,1,&n,&feaspec);
      vis_ConnectElemAssoc (connect,VIS_PROPID,1,&n,&pid);
      vsy_HashTableLookup (eproph,pid,(Vobject**)&eprop);

      if(featype == SYS_ELEM_SOLID) {
         vfe_Solid3DSetTopology (solid3d,shape,maxi,maxj,maxk);
         vfe_Solid3DSetParami (solid3d,VFE_TECH,featech);
         vfe_Solid3DNumDof (solid3d,VFE_ANALYSIS_STRUCTURAL,&nedofs);
         vfe_Solid3DDofMap (solid3d,VFE_ANALYSIS_STRUCTURAL,loc,tag);
         vis_EPropValueInteger (eprop,EPROP_MID,&mid);
         vsy_HashTableLookup (matlfunh,mid,(Vobject**)&matlfun);
         vfe_Solid3DSetObject (solid3d,VFE_MATLFUN,matlfun);
         vfs_DofTabElemDof (doftab,n,nix,ix,&nedofs,lm);
         vfs_SysVectorGather (sysV,nedofs,lm,u);
         vfe_Solid3DStrsStrn (solid3d,xl,u,strs,strn);
         if(verbose) {
            for(i = 0; i < nix; i++) {
               printf(" node= %d\n",ix[i]);
               j = i*6;
               printf(" sxx,syy,szz= %f %f %f\n",strs[j+0],strs[j+1],strs[j+2]);
               printf(" sxy,syz,szx= %f %f %f\n",strs[j+3],strs[j+4],strs[j+5]);
            }
         }
         vis_StateSetDatadv (stateent,n,strs);
      } else if(featype == SYS_ELEM_SHELL) {
         vfe_Shell3DSetTopology (shell3d,shape,maxi,maxj);
         vfe_Shell3DSetParami (shell3d,VFE_TECH,featech);
         vfe_Shell3DNumDof (shell3d,VFE_ANALYSIS_STRUCTURAL,&nedofs);
         vfe_Shell3DDofMap (shell3d,VFE_ANALYSIS_STRUCTURAL,loc,tag);
         vsy_HashTableLookup (eproph,pid,(Vobject**)&eprop);
         vis_EPropValueInteger (eprop,EPROP_MID,&mid);
         vsy_HashTableLookup (matlfunh,mid,(Vobject**)&matlfun);
         vfe_ShellPropSetMatlFun (shellprop,1,matlfun);
         vis_EPropEvaldv (eprop,EPROP_THICKNESS,shape,maxi,maxj,fb->thickness);
         vfs_DofTabElemDof (doftab,n,nix,ix,&nedofs,lm);
         vfs_SysVectorGather (sysV,nedofs,lm,u);
         vfe_Shell3DStrsStrn (shell3d,xl,u,strs,strn);
         vfe_Shell3DDirCos (shell3d,xl,u,tm);
         if(verbose) {
            for(i = 0; i < nix; i++) {
               printf(" node= %d\n",ix[i]);
               j = i*8;
               printf(" Nxx,Nyy,Nxy= %f %f %f\n",strs[j+0],strs[j+1],strs[j+2]);
               printf(" Mxx,Myy,Mxy= %f %f %f\n",strs[j+3],strs[j+4],strs[j+5]);
               printf(" Qxz,Qyz= %f %f\n",strs[j+6],strs[j+7]);
            }
         }
         /*
          * The variable "z" is the distance from the mid-surface.
          * if z == 0., then the point is at the mid-surface
          * if z == +thickness/2., then the point is on the top surface
          * if z == -thickness/2., then the point is on the bottom surface
          *
          * The example shows the stress on the top surface, as z is set to
          * +thickness/2. Users can extract stresses at any point by using
          * the formulae below
          */
         for(i = 0; i < nix; i++) {
            j  = i*8;
            t  = fb->thickness[i];
            t2 = t*t;
            z  = t/2.;
            z2 = z*z;
            factor1 = 12.*z/t2;
            factor2 = 1.5*(1. - 4.*z2/t2)/t;
            lstrs[0] = strs[j+0] / t + factor1*strs[j+3];
            lstrs[1] = strs[j+1] / t + factor1*strs[j+4];
            lstrs[2] = 0.;
            lstrs[3] = strs[j+2] / t + factor1*strs[j+5];
            lstrs[4] = factor2*strs[j+7];
            lstrs[5] = factor2*strs[j+6];
            transStress3D (tm[i],stm);
            matvecprod6 (stm,lstrs,gstrs[i]);
         }
         vis_StateSetDatadv (stateent,n,(Vdouble*)gstrs);
      } else if(featype == SYS_ELEM_BEAM) {
         vfe_Beam3DSetTopology (beam3d,maxi);
         vfe_Beam3DSetParami (beam3d,VFE_TECH,featech);
         vfe_Beam3DNumDof (beam3d,VFE_ANALYSIS_STRUCTURAL,&nedofs);
         vfe_Beam3DDofMap (beam3d,VFE_ANALYSIS_STRUCTURAL,loc,tag);
         vsy_HashTableLookup (eproph,pid,(Vobject**)&eprop);
         vis_EPropValueInteger (eprop,EPROP_MID,&mid);
         vsy_HashTableLookup (matlfunh,mid,(Vobject**)&matlfun);
         vfe_BeamPropSetMatlFun (beamprop,1,matlfun);
         vis_EPropEvaldv (eprop,EPROP_AREA,shape,maxi,maxj,fb->area);
         vis_EPropEvaldv (eprop,EPROP_IYY, shape,maxi,maxj,fb->iyy);
         vis_EPropEvaldv (eprop,EPROP_IZZ, shape,maxi,maxj,fb->izz);
         vis_EPropEvaldv (eprop,EPROP_IYZ, shape,maxi,maxj,fb->iyz);
         vis_EPropEvaldv (eprop,EPROP_J,   shape,maxi,maxj,fb->jtr);
         vfs_DofTabElemDof (doftab,n,nix,ix,&nedofs,lm);
         vfs_SysVectorGather (sysV,nedofs,lm,u);
         vfe_Beam3DStrsStrn (beam3d,xl,u,strs,strn);
         vfe_Beam3DDirCos (beam3d,xl,u,tm);
         if(verbose) {
            for(i = 0; i < nix; i++) {
               printf(" node= %d\n",ix[i]);
               j = i*6;
               printf(" N,Myy,Mzz= %f %f %f\n",strs[j+0],strs[j+1],strs[j+2]);
               printf(" T,Qxy,Qzx= %f %f %f\n",strs[j+3],strs[j+4],strs[j+5]);
            }
         }
         for(i = 0; i < nix; i++) {
            j = i*6;
            lstrs[0] = strs[j+0] / fb->area[i];
            lstrs[1] = 0.;
            lstrs[2] = 0.;
            lstrs[3] = strs[j+4] / fb->area[i];
            lstrs[4] =