Table of Contents

25. Examples - Global Modules

This chapter contains example VisTools programs demonstrating the use of the "global" objects. The source code for all examples resides in devtools/src/vis/exam.

Table of Contents

25.1 Example 21, Translate Entity Identifiers Using IdTran.

This example illustrates using an IdTran object to translate entity identifiers to a sequential index space. The vis_IdTranDef function is used to specify the number of entities (5). The identifier for each index is specified using vis_IdTranSetId. Depending upon the nature of the identifier to index mapping, the IdTran module will attempt to optimize the internal data structures and algorithms used to perform the translation. The identifiers used in this example are a worst case condition in that the index to identifier mapping is non monotonic.

The function vis_IdTranIndex is used to return the index of each identifier. An index of 0 is returned if an unrecognized identifier is input.

Next the IdTran object is used to manage an element face set. The function IdTranClear is used to clear all identifiers to zero. Three element faces are specified and each element face must be given a unique index. First the element identifier associated with the index must be specified using vis_IdTranSetId then the face number is set using vis_IdTranSetEnt. The values returned by vis_IdTranCount reflect that the number of indices is 3 while the number of unique identifiers is 2.

The example also illustrates managing equivalenced identifiers using vis_IdTranEquId and vis_IdTranEquSweep. Any set of equivalenced pairs may be inserted one pair of equivalences at a time using vis_IdTranEquId. The function vis_IdTranClear must be called before the equivalences are set. In this case the identifiers 1,2,4 and 5 are equivalenced. The equivalences may be entered using 3 equivalenced pairs. Once the pairs are specified, call vis_IdTranEquSweep to sweep through and process the equivalences so that all identifiers point to the lowest common equivalenced node. In this case identifiers 2,4 and 5 will point to identifier 1.

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

static Vint ids[5] = {
   2,33,14,25,8 };

/*----------------------------------------------------------------------
                      Build and query an IdTran object
----------------------------------------------------------------------*/
int
main()
{
   vis_IdTran *idtran;
   vis_IdTran *idtrana;
   Vint i;
   Vint index, id, no;
   Vint match;
   Vint num;
   Vint numind, numuni;

                   /* create IdTran object */ 
   idtran = vis_IdTranBegin ();

                   /* specify 5 entities */
   vis_IdTranDef (idtran,5);

                   /* set identifier for each entity index */
   for(i = 0; i < 5; i++) {
      vis_IdTranSetId (idtran,i+1,ids[i]);
   }
                   /* query and print index of each identifier */
   for(i = 0; i < 5; i++) {
      vis_IdTranIndex (idtran,ids[i],&index);
      printf("identifier = %d, index = %d\n",ids[i],index);
   }
                   /* query and print index of illegal identifier */
   vis_IdTranIndex (idtran,-44,&index);
   printf("identifier = %d, index = %d\n",-44,index);

                   /* check for matching objects */
   idtrana = vis_IdTranBegin ();
   vis_IdTranDef (idtrana,5);
   for(i = 0; i < 5; i++) {
      vis_IdTranSetId (idtrana,i+1,ids[i]);
   }
                   /* this should match */ 
   vis_IdTranMatch (idtran,idtrana,&match);
   printf("match = %d\n",match);

                   /* this should not match */ 
   vis_IdTranSetId (idtrana,2,3);
   vis_IdTranMatch (idtran,idtrana,&match);
   printf("match = %d\n",match);

                   /* query for unique identifiers */ 
   vis_IdTranSetId (idtran,2,25);
   vis_IdTranCount (idtran,IDTRAN_NUMINDICES,&numind);
   vis_IdTranCount (idtran,IDTRAN_NUMUNIQUE,&numuni);
   printf("numind= %d, numuni= %d\n",numind,numuni);
   vis_IdTranSetId (idtran,3,0);
   vis_IdTranCount (idtran,IDTRAN_NUMINDICES,&numind);
   vis_IdTranCount (idtran,IDTRAN_NUMUNIQUE,&numuni);
   printf("numind= %d, numuni= %d\n",numind,numuni);
   vis_IdTranClear (idtrana);
   vis_IdTranUnique (idtrana,idtran);
                   /* query and print unique identifiers */ 
   for(i = 1; i <= numuni; i++) {
      vis_IdTranGetId (idtrana,i,&id);
      printf("index = %d, identifier = %d\n",i,id);
   }
   vis_IdTranEnd (idtrana);

                   /* manage an element face set */
   vis_IdTranClear (idtran);
                   /* element 3, face 2 */ 
   vis_IdTranSetEntType (idtran,SYS_ELEM,SYS_FACE);
   vis_IdTranSetId (idtran,1,3);
   vis_IdTranSetEnt (idtran,1,2);
                   /* element 4, faces 1 and 3 */ 
   vis_IdTranSetId (idtran,2,4);
   vis_IdTranSetEnt (idtran,2,1);
   vis_IdTranSetId (idtran,3,4);
   vis_IdTranSetEnt (idtran,3,3);
   vis_IdTranCount (idtran,IDTRAN_NUMINDICES,&numind);
   vis_IdTranCount (idtran,IDTRAN_NUMUNIQUE,&numuni);
   printf("numind= %d, numuni= %d\n",numind,numuni);
                   /* query and print identifiers and face numbers */ 
   for(i = 1; i <= numind; i++) {
      vis_IdTranGetId (idtran,i,&id);
      vis_IdTranGetEnt (idtran,i,&no);
      printf("index = %d, identifier = %d, face number= %d\n",i,id,no);
   }

                   /* manage equivalenced identifiers, 1,2,4,5 */ 
   vis_IdTranClear (idtran);
                   /* enter identifiers pairs in some arbitrary way */
   vis_IdTranEquId (idtran,1,2);
   vis_IdTranEquId (idtran,4,5);
   vis_IdTranEquId (idtran,4,2);
   vis_IdTranEquSweep (idtran);
   for(i = 1; i <= 5; i++) {
      vis_IdTranGetId (idtran,i,&index);
      if(index) {
         printf("equivalence id = %d to id = %d\n",i,index);
      }
   }
   vis_IdTranEquReNumber (idtran,&num);
   printf("Number of unique nodes= %d\n",num);
   for(i = 1; i <= 5; i++) {
      vis_IdTranGetId (idtran,i,&index);
      printf("index= %d, new id = %d\n",i,index);
   }

                   /* free objects */
   vis_IdTranEnd (idtran);
   return 0;
}


Table of Contents

25.2 Example 22, Generate an Element Group Object

This example generates an element Group object containing 16 elements with an index offset of one. Initially, elements with index 2 and 13 are set active. The Group module provides two distinct methods for querying for active entities. The first involves using vis_GroupInitIndex followed by successive calls to vis_GroupNextIndex. The second uses a straightforward loop calling vis_GroupGetIndex.

The "while" loop illustrates the first method for querying for active elements in a group which is particularly effective if the group is sparsely active. Then the complement of the active elements is generated. This operation sets the original active elements inactive and vice versa. The "for" loop illustrates the second method for querying for the new active elements in the group.

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

#define MAX_ELEM 16

/*----------------------------------------------------------------------
                      Generate element group object
----------------------------------------------------------------------*/
int
main()
{
   vis_Group *group, *groups;

   Vint i;
   Vint index, flag;

                   /* create element group object */ 
   group = vis_GroupBegin ();
   vis_GroupDef (group,MAX_ELEM,SYS_ELEM,SYS_NONE);

                   /* activate the 2nd and 13th elements */
   vis_GroupClear (group);
   vis_GroupSetIndex (group,2,1);
   vis_GroupSetIndex (group,13,1);

                   /* return active elements using Init-Next facility */
   vis_GroupInitIndex (group);
   while (vis_GroupNextIndex (group,&index,&flag), index != 0) {
      printf("element index = %d, flag = %d\n",index,flag);
   }

                   /* take complement of group */
   vis_GroupComplement (group);

                   /* return active elements using GetIndex facility */
   for(i = 1; i <= MAX_ELEM; i++) {
      vis_GroupGetIndex (group,i,&flag);
      if(flag) {
         printf("element index = %d, flag = %d\n",i,flag);
      }
   }
                   /* perform boolean operation */ 
   groups = vis_GroupBegin ();
   vis_GroupDef (groups,MAX_ELEM,SYS_ELEM,SYS_NONE);

                   /* activate even elements */ 
   for(i = 2; i <= MAX_ELEM; i+=2) {
      vis_GroupSetIndex (groups,i,flag);
   }
                   /* delete all even elements from group */ 
   vis_GroupBoolean (group,GROUP_DELETE,groups);

                   /* return active elements using Init-Next facility */
   vis_GroupInitIndex (group);
   while (vis_GroupNextIndex (group,&index,&flag), index != 0) {
      printf("element index = %d, flag = %d\n",index,flag);
   }
   
                   /* end objects */ 
   vis_GroupEnd (group);
   vis_GroupEnd (groups);
   return 0;
}


Table of Contents

25.3 Example 23, Element Connectivity and Adjacency using Connect

This example generates a small finite element model consisting of two 8-node hexahedra and one 4-node quadrilateral. The connectivity of the three elements is illustrated in the example source below, the elements are indexed from left to right. A Connect object is instanced to hold element topology, connectivity and node coordinates. At this point, these same quantities may be queried as well as other non-adjacency related quantities such as the number of edges in an element, etc. Before element adjacencies may be queries the connection kernel must be formed by calling vis_ConnectKernel. The connection kernel also allows the generation of derived groups which is discussed in the next example, Example 24.

#include <stdio.h>
#include "base/base.h"
#include "vis/vis.h"
/*
                 5------6
                /.     /.\
  y            / .    / . \
  |           /  .   /  .  \7------8
  --x        /   1../...2../|      |
 /         12-----13-----14 |      |
z           |  .   |  .   |.|      |
            | .    | .    | 3------4
            |.     |.     |/
            9-----10-----11
*/
#define MAX_ELEM  3
#define MAX_NODE 14

static Vint conn[MAX_ELEM][8] = {
   {1, 2, 6, 5, 9,10,13,12},
   {2, 3, 7, 6,10,11,14,13},
   {3, 4, 8, 7, 0, 0, 0, 0} };

static Vint shap[MAX_ELEM] = {
   VIS_SHAPEHEX, VIS_SHAPEHEX, VIS_SHAPEQUAD };

static Vfloat coords[MAX_NODE][3] = {
   {0.,0.,0.},  {1.,0.,0.},  {2.,0.,1.},  {3.,0.,1.}, 
   {0.,1.,0.},  {1.,1.,0.},  {2.,1.,1.},  {3.,1.,1.}, 
   {0.,0.,2.},  {1.,0.,2.},  {2.,0.,2.},
   {0.,1.,2.},  {1.,1.,2.},  {2.,1.,2.} };

/*----------------------------------------------------------------------
                      Element Connectivity and Adjacency using Connect
----------------------------------------------------------------------*/
int
main()
{
   vis_Connect *connect;
   Vint i;
   Vint nfaces, nedges, nnodes;
   Vint nix, ix[64], no[64];
   Vfloat x[64][3];
   Vint nindices, indices[2];

                   /* create connect object */
   connect = vis_ConnectBegin ();
   vis_ConnectDef (connect,MAX_NODE,MAX_ELEM);

                   /* set topologies */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetTopology (connect,i+1,shap[i],2,0,0);
   }
                   /* set element node connectivity */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetElemNode (connect,i+1,conn[i]);
   }
                   /* set node coordinates */ 
   for(i = 0; i < MAX_NODE; i++) {
      vis_ConnectSetCoords (connect,i+1,coords[i]);
   }

                   /* print element connection info */ 
   printf("Example 23, Using Connect\n");
   printf("element - number of faces, edges, nodes\n");
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectElemNum (connect,SYS_FACE,i+1,&nfaces);
      vis_ConnectElemNum (connect,SYS_EDGE,i+1,&nedges);
      vis_ConnectElemNum (connect,SYS_NODE,i+1,&nnodes);
      printf("%5d              %5d  %5d  %5d\n",i+1,nfaces,nedges,nnodes);
   }
                   /* node connectivity query for element 1 */ 
   vis_ConnectElemNode (connect,1,&nix,ix);
   vis_ConnectCoords (connect,nix,ix,x);
   printf("element node - connected node, coordinates\n");
   for(i = 0; i < nix; i++) {
      printf("%5d                %3d",i+1,ix[i]);
      printf("       %f  %f  %f\n",x[i][0],x[i][1],x[i][2]);
   }
                   /* generate connect kernel */
   vis_ConnectKernel (connect,0);

                   /* element adjacency query for element 1 */ 
   vis_ConnectElemNum (connect,SYS_FACE,1,&nfaces);
   printf("element face - adjacent element entity\n");
   for(i = 0; i < nfaces; i++) {
      vis_ConnectElemAdjEnt (connect,SYS_FACE,1,i+1,&nix,ix,no);
                   /* test for adjacent element */
      if(nix) {
         printf("%5d                %3d %3d\n",i+1,ix[0],no[0]);
      } else {
         printf("%5d               none\n",i+1);
      }
   }
                   /* query elements connected to both nodes 3 and 11 */ 
   nindices = 2;
   indices[0] = 3;
   indices[1] = 11;
   vis_ConnectNodeAdj (connect,nindices,indices,&nix,ix);
   printf("adjacent element\n");
   for(i = 0; i < nix; i++) {
      printf("%5d\n",ix[i]);
   }
                   /* end objects */ 
   vis_ConnectEnd (connect);
   return 0;
}

Table of Contents

25.4 Example 23a, Using a GridFun Object with Example 23.

This example illustrates using a GridFun (grid function) object to query an external source for element topology and connectivity and node coordinates from a Connect object. This is a modification of Example 23 in which the equivalent element and node information is loaded directly into the Connect object. The use of grid functions may be preferred by a host application if it has been designed to maintain the basic element topology and connectivity and node coordinates in data structures external to the Connect object. Using a GridFun object as a query mechanism eliminates the memory required to duplicate the basic model information in data structures internal to the Connect object.

All Connect object query functions are invariant with respect to the two approaches illustrated in this example and Example 23. The output from both examples is identical.

Note that the grid functions registered in the GridFun object provide for a user specified pointer (object) to be passed as the first argument. In this example the pointer argument is not used so it will be passed as a NULL pointer (the default). The four required grid functions are Topology, MaxElemNode, ElemNode and Coords. If query for node and element associations is desired, the NodeAssoc and ElemAssoc functions must also be registered.

#include <stdio.h>
#include "base/base.h"
#include "vis/vis.h"
/*
                 5------6
                /.     /.\
               / .    / . \
              /  .   /  .  \7------8
             /   1../...2../|      |
           12-----13-----14 |      |
            |  .   |  .   |.|      |
            | .    | .    | 3------4
            |.     |.     |/
            9-----10-----11
*/
#define MAX_ELEM  3
#define MAX_NODE 14

static Vint numconn[MAX_ELEM] = {
   8, 8, 4 };

static Vint conn[MAX_ELEM][8] = {
   {1, 2, 6, 5, 9,10,13,12},
   {2, 3, 7, 6,10,11,14,13},
   {3, 4, 8, 7, 0, 0, 0, 0} };

static Vint shap[MAX_ELEM] = {
   VIS_SHAPEHEX, VIS_SHAPEHEX, VIS_SHAPEQUAD };

static Vfloat coords[MAX_NODE][3] = {
   {0.,0.,0.},  {1.,0.,0.},  {2.,0.,1.},  {3.,0.,1.}, 
   {0.,1.,0.},  {1.,1.,0.},  {2.,1.,1.},  {3.,1.,1.}, 
   {0.,0.,2.},  {1.,0.,2.},  {2.,0.,2.},
   {0.,1.,2.},  {1.,1.,2.},  {2.,1.,2.} };

/*----------------------------------------------------------------------
                      Grid functions for model description
----------------------------------------------------------------------*/
static void
exam_Topology(Vobject *obj,
              Vint id, Vint *shape, Vint *maxi, Vint *maxj, Vint *maxk)
{
   *shape = shap[id-1];
   *maxi = 2;
   *maxj = 0;
   *maxk = 0;
}

static void
exam_MaxElemNode(Vobject *obj, Vint *maxnum)
{
   *maxnum = 8;
}

static void
exam_ElemNode(Vobject *obj, Vint id, Vint *nix, Vint ix[])
{
   int i;

   *nix = numconn[id-1];
   for(i = 0; i < *nix; i++) {
      ix[i] = conn[id-1][i];
   }
}

static void
exam_Coords(Vobject *obj, Vint nids, Vint ids[], Vfloat x[][3])
{
   int i;

   for(i = 0; i < nids; i++) {
      x[i][0] = coords[ids[i]-1][0];
      x[i][1] = coords[ids[i]-1][1];
      x[i][2] = coords[ids[i]-1][2];
   }
}

/*----------------------------------------------------------------------
                      Element Connectivity and Adjacency using Connect
----------------------------------------------------------------------*/
int
main()
{
   vis_Connect *connect;
   vis_GridFun *gf;
   Vint i;
   Vint nfaces, nedges, nnodes;
   Vint nix, ix[64];
   Vfloat x[64][3];
   Vint nindices, indices[2];

                   /* create connect object */
   connect = vis_ConnectBegin ();
   vis_ConnectDef (connect,MAX_NODE,MAX_ELEM);

                   /* create gridfun object */ 
   gf = vis_GridFunBegin ();

                   /* register example grid functions */
   vis_GridFunSet (gf,GRIDFUN_TOPOLOGY,    (void(*)(void))exam_Topology);
   vis_GridFunSet (gf,GRIDFUN_MAXELEMNODE, (void(*)(void))exam_MaxElemNode);
   vis_GridFunSet (gf,GRIDFUN_ELEMNODE,    (void(*)(void))exam_ElemNode);
   vis_GridFunSet (gf,GRIDFUN_COORDS,      (void(*)(void))exam_Coords);

                   /* set grid function as attribute to connect */ 
   vis_ConnectSetObject (connect,VIS_GRIDFUN,gf);

                   /* print element connection info */ 
   printf("Example 23a, Using Connect with a GridFun object\n");
   printf("element - number of faces, edges, nodes\n");
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectElemNum (connect,SYS_FACE,i+1,&nfaces);
      vis_ConnectElemNum (connect,SYS_EDGE,i+1,&nedges);
      vis_ConnectElemNum (connect,SYS_NODE,i+1,&nnodes);
      printf("%5d              %5d  %5d  %5d\n",i+1,nfaces,nedges,nnodes);
   }
                   /* node connectivity query for element 1 */ 
   vis_ConnectElemNode (connect,1,&nix,ix);
   vis_ConnectCoords (connect,nix,ix,x);
   printf("element node - connected node, coordinates\n");
   for(i = 0; i < nix; i++) {
      printf("%5d                %3d",i+1,ix[i]);
      printf("       %f  %f  %f\n",x[i][0],x[i][1],x[i][2]);
   }

                   /* generate connect kernel */
   vis_ConnectKernel (connect,0);

                   /* element adjacency query for element 1 */ 
   vis_ConnectElemNum (connect,SYS_FACE,1,&nfaces);
   printf("element face - adjacent element\n");
   for(i = 0; i < nfaces; i++) {
      vis_ConnectElemAdj (connect,SYS_FACE,1,i+1,&nix,ix);
                   /* test for adjacent element */
      if(nix) {
         printf("%5d                %3d\n",i+1,ix[0]);
      } else {
         printf("%5d               none\n",i+1);
      }
   }

                   /* query elements connected to both nodes 3 and 11 */
   nindices = 2;
   indices[0] = 3;
   indices[1] = 11;
   vis_ConnectNodeAdj (connect,nindices,indices,&nix,ix);
   printf("adjacent element\n");
   for(i = 0; i < nix; i++) {
      printf("%5d\n",ix[i]);
   }

                   /* end objects */ 
   vis_ConnectEnd (connect);
   vis_GridFunEnd (gf);
   return 0;
}

Table of Contents

25.5 Example 24, Generate Element Face and Edge Groups

This example uses the same finite element model introduced in Example 23 and illustrates the generation of four useful groups, a group of element free faces and three groups of element edges - unique edges, free edges and feature edges. Element free faces are those faces connected to a single element and generally form a set of exterior faces for the finite element model. Unique edges are useful for drawing a wireframe display of the finite element model without drawing any edge more than once. Free edges are those edges connected to only one element. In hexahedral meshes, free edges often represent the corner edges of the mesh. Feature edges are those edges lying on the exterior of the mesh which connect adjacent faces which form a discontinuity at the edge. These edges are relatively expensive to compute since they involve the calculation of geometric normals to the free faces. However, feature edges represent corner edges on meshes containing non hexahedral elements.

Seeded faces are those faces adjacent to a specified seed node or seed element face. In this example a seed element face is specified. The algorithm selects all faces contained in the source face group, in this case the free faces, which are adjacent to the seed face and adjacent to previously selected faces. In this manner, selected faces propagate out from the seed face. The selection process is bounded by an element edge group. Normally the element edge group forms a closed loop about the seed element face.

Silhouette edges are those edges shared by two faces which form an outline when viewed from a given direction. The user must load a 4 by 4 "model view" matrix to specify the orientation of model with respect to the eye coordinate system. An edge is considered to be a silhouette edge if one of the adjacent faces is back facing while the other is front facing.

The connection kernel must be generated before the derived groups may be generated. The contents of the groups are printed. Notice that the internal face shared by elements 1 and 2 is not included in the free element face group. Likewise each edge in the finite element model should be flagged by only one element in the element edge group.

#include <stdio.h>
#include "base/base.h"
#include "vis/vis.h"
/*
                 5------6
                /.     /.\
  y            / .    / . \
  |           /  .   /  .  \7------8
  --x        /   1../...2../|      |
 /         12-----13-----14 |      |
z           |  .   |  .   |.|      |
            | .    | .    | 3------4
            |.     |.     |/
            9-----10-----11
*/
static void
printflags(vis_Group *group, Vchar *stg, Vint numelem);

#define MAX_ELEM  3
#define MAX_NODE 14

static Vint conn[MAX_ELEM][8] = {
   {1, 2, 6, 5, 9,10,13,12},
   {2, 3, 7, 6,10,11,14,13},
   {3, 4, 8, 7, 0, 0, 0, 0} };

static Vint shap[MAX_ELEM] = {
   VIS_SHAPEHEX, VIS_SHAPEHEX, VIS_SHAPEQUAD };

static Vfloat coords[MAX_NODE][3] = {
   {0.,0.,0.},  {1.,0.,0.},  {2.,0.,1.},  {3.,0.,1.},
   {0.,1.,0.},  {1.,1.,0.},  {2.,1.,1.},  {3.,1.,1.},
   {0.,0.,2.},  {1.,0.,2.},  {2.,0.,2.},
   {0.,1.,2.},  {1.,1.,2.},  {2.,1.,2.} };

/*----------------------------------------------------------------------
                      Generate Element Face and Edge Groups using Connect
----------------------------------------------------------------------*/
int
main()
{
   vis_Connect *connect;
   vis_Group *groupface, *groupedge;
   vis_Group *groupfaceseed;
   Vfloat c, s, ctm[4][4];

   Vint i;

                   /* create connect object */
   connect = vis_ConnectBegin ();
   vis_ConnectDef (connect,MAX_NODE,MAX_ELEM);

                   /* set topologies */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetTopology (connect,i+1,shap[i],2,0,0);
   }

                   /* set element node connectivity */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetElemNode (connect,i+1,conn[i]);
   }

                   /* set node coordinates */
   for(i = 0; i < MAX_NODE; i++) {
      vis_ConnectSetCoords (connect,i+1,coords[i]);
   }

                   /* generate connect kernel */
   vis_ConnectKernel (connect,0);

                   /* create element face group */ 
   groupface = vis_GroupBegin ();
   vis_GroupDef (groupface,MAX_ELEM,SYS_ELEM,SYS_FACE);

                   /* generate group of element free faces */
   vis_ConnectFaceGroup (connect,CONNECT_FREE,NULL,groupface);
   printflags (groupface,"element - free faces",MAX_ELEM);

                   /* create element edge group */ 
   groupedge = vis_GroupBegin ();
   vis_GroupDef (groupedge,MAX_ELEM,SYS_ELEM,SYS_EDGE);

                   /* generate group of element unique edges */
   vis_ConnectEdgeGroup (connect,CONNECT_UNIQUE,NULL,groupedge);
   printflags (groupedge,"element - unique edges",MAX_ELEM);

                   /* generate group of element free edges */
   vis_GroupClear (groupedge);
   vis_ConnectEdgeGroup (connect,CONNECT_FREE,NULL,groupedge);
   printflags (groupedge,"element - free edges",MAX_ELEM);

                   /* generate group of element face feature edges */
   vis_GroupClear (groupedge);
   vis_ConnectEdgeGroup (connect,CONNECT_FEATURE,groupface,groupedge);
   printflags (groupedge,"element - element face feature edges",MAX_ELEM);

                   /* generate group of element faces from seeded face */
                   /* seed element 1 face 4 (top face) */
                   /* containing only free faces and bounded by feature edges */
   groupfaceseed = vis_GroupBegin ();
   vis_GroupDef (groupfaceseed,MAX_ELEM,SYS_ELEM,SYS_FACE);
   vis_GroupClear (groupfaceseed);
   vis_ConnectSetGroupParami (connect,CONNECT_SEEDELEM,1);
   vis_ConnectSetGroupParami (connect,CONNECT_SEEDFACE,4);
   vis_ConnectSetGroupObject (connect,CONNECT_SEEDGROUP,groupedge);
   vis_ConnectFaceGroup (connect,CONNECT_SEED,groupface,groupfaceseed);
   printflags (groupfaceseed,"element - element face seeded",MAX_ELEM);

                   /* generate group of element face silhouette edges */ 
                   /* load model view matrix */
   c = 0.866026;
   s = 0.500000;
   ctm[0][0] = 1.0; ctm[1][0] = 0.0;  ctm[2][0] =  0.0;  ctm[3][0] = 0.0;
   ctm[0][1] = 0.0; ctm[1][1] = c;    ctm[2][1] = -s;    ctm[3][1] = 0.0;
   ctm[0][2] = 0.0; ctm[1][2] = s;    ctm[2][2] =  c;    ctm[3][2] = 0.0;
   ctm[0][3] = 0.0; ctm[1][3] = 0.0;  ctm[2][3] =  0.0;  ctm[3][3] = 1.0;
   vis_ConnectSetGroupParamfv (connect,CONNECT_MODELVIEWMATRIX,(Vfloat*)ctm);

   vis_GroupClear (groupedge);
   vis_ConnectEdgeGroup (connect,CONNECT_SILHOUETTE,groupface,groupedge);
   printflags (groupedge,"element - element face silhouette edges",MAX_ELEM);

                   /* end objects */ 
   vis_ConnectEnd (connect);
   vis_GroupEnd (groupface);
   vis_GroupEnd (groupfaceseed);
   vis_GroupEnd (groupedge);
   return 0;
}

/*----------------------------------------------------------------------
                      print elem edge or elem face flags in a group
----------------------------------------------------------------------*/
static void
printflags(vis_Group *group, Vchar *stg, Vint numelem)
{
   Vint i;
   Vint flags;

   printf("%s\n",stg);
   for(i = 0; i < numelem; i++) {
      vis_GroupGetIndex (group,i+1,&flags);
      printf("%5d      %3x\n",i+1,flags);
   }
}

Table of Contents

25.6 Example 24a, Convert Linear Elements to Parabolic Elements

This example uses the same finite element model introduced in Example 23 and illustrates using the Connect object and a multi-integer hashtable, IntVHash, to convert a model of linear elements to parabolic Serendipity elements. In this case a midside node is generated on each unique edge. The IntVHash module is used to store the midside node associated with each unique edge. The vis_ConnectEdgeGroup function is used to generate a Group of unique edges. Each unique edge is visited and a node is generated at the mid-edge location for each edge. A Connect object, connectp is instanced to hold the parabolic elements.

After the midside nodes are generated, the edges of the linear elements are traversed and the midside node for each edge is added to the element connectivity and set in connectp. Note that for parabolic Serendipity elements the corner node connectivity is identical to the linear element and the midside nodes are added in edge order after the corner node connectivity.

#include <stdio.h>
#include "base/base.h"
#include "vis/vis.h"
/*
                 5------6
                /.     /.\
  y            / .    / . \
  |           /  .   /  .  \7------8
  --x        /   1../...2../|      |
 /         12-----13-----14 |      |
z           |  .   |  .   |.|      |
            | .    | .    | 3------4
            |.     |.     |/
            9-----10-----11
*/

#define MAX_ELEM  3
#define MAX_NODE 14

static Vint conn[MAX_ELEM][8] = {
   {1, 2, 6, 5, 9,10,13,12},
   {2, 3, 7, 6,10,11,14,13},
   {3, 4, 8, 7, 0, 0, 0, 0} };

static Vint shap[MAX_ELEM] = {
   VIS_SHAPEHEX, VIS_SHAPEHEX, VIS_SHAPEQUAD };

static Vfloat coords[MAX_NODE][3] = {
   {0.,0.,0.},  {1.,0.,0.},  {2.,0.,1.},  {3.,0.,1.},
   {0.,1.,0.},  {1.,1.,0.},  {2.,1.,1.},  {3.,1.,1.},
   {0.,0.,2.},  {1.,0.,2.},  {2.,0.,2.},
   {0.,1.,2.},  {1.,1.,2.},  {2.,1.,2.} };

/*----------------------------------------------------------------------
                      Convert Linear Elements to Parabolic Elements
----------------------------------------------------------------------*/
int
main()
{
   Vint i, j;
   vis_Connect *connect, *connectp;
   vis_Group *groupedge;
   vsy_IntVHash *ivh;
   Vint numnp, numel, numnpp;
   Vint nelem, nedge;
   Vint index, nix, ix[20], ixs, nid, nex, iex[2], ned;
   Vint shape, maxi, maxj, maxk;
   Vfloat xe[2][3], xm[3];
   Vint flags, flag, numno, maxno;

   numnp = MAX_NODE;
   numel = MAX_ELEM;
   printf("number of corner nodes=    %d\n",numnp);
   printf("number of linear elements= %d\n",numel);
                   /* create connect object to hold linear elements */
   connect = vis_ConnectBegin ();
   vis_ConnectDef (connect,numnp,numel);
                   /* set node coordinates */
   for(i = 0; i < numnp; i++) {
      vis_ConnectSetCoords (connect,i+1,coords[i]);
   }
                   /* set topologies */ 
   for(i = 0; i < numel; i++) {
      vis_ConnectSetTopology (connect,i+1,shap[i],2,0,0);
   }
                   /* set element node connectivity */ 
   for(i = 0; i < numel; i++) {
      vis_ConnectSetElemNode (connect,i+1,conn[i]);
   }
                   /* generate connect kernel for adjacency type queries */
   vis_ConnectKernel (connect,0);

                   /* generate group of element unique edges */
   groupedge = vis_GroupBegin ();
   vis_GroupDef (groupedge,numel,SYS_ELEM,SYS_EDGE);
   vis_ConnectEdgeGroup (connect,CONNECT_UNIQUE,NULL,groupedge);
                   /* count unique edges */ 
   vis_GroupCount (groupedge,&nelem,&nedge);
   printf("number of unique edges= %d\n",nedge);

                   /* create connect object to hold parabolic elements */
   numnpp = numnp + nedge;
   connectp = vis_ConnectBegin ();
   vis_ConnectDef (connectp,numnpp,numel);
                   /* copy original corner nodes */ 
   for(i = 1; i <= numnp; i++) {
      vis_ConnectCoords (connect,1,&i,xe);
      vis_ConnectSetCoords (connectp,i,xe[0]);
   }
                   /* put unique edges in a hashtable */ 
                   /* one midside node will be generated per unique edge */
   ivh = vsy_IntVHashBegin();
   vsy_IntVHashDef (ivh,2,nedge);
   nid = numnp;
   vis_GroupInitIndex (groupedge);
   while(vis_GroupNextIndex (groupedge,&index,&flags),index) {
      vis_GroupNumEntFlag (groupedge,index,&numno,&maxno);
      for(j = 1; j <= maxno; j++) {
         vis_GroupGetEntFlag (groupedge,index,j,&flag);
         if(flag) {
            vis_ConnectElemCon (connect,SYS_EDGE,index,j,&nex,iex);
            vis_ConnectCoords (connect,2,iex,xe);
            xm[0] = .5*(xe[0][0] + xe[1][0]);
            xm[1] = .5*(xe[0][1] + xe[1][1]);
            xm[2] = .5*(xe[0][2] + xe[1][2]);
                   /* make sure that the edge nodes are lowest first */ 
            if(iex[0] > iex[1]) {
               ixs = iex[0];
               iex[0] = iex[1];
               iex[1] = ixs;
            }
            nid += 1;
            vis_ConnectSetCoords (connectp,nid,xm);
            vsy_IntVHashInsert (ivh,iex,nid);
         }
      }
   }
                   /* now loop through elements and insert edge midsides */
                   /* promote topology to parabolic Serendipity */
   for(i = 1; i <= numel; i++) {
      vis_ConnectTopology (connect,i,&shape,&maxi,&maxj,&maxk);
      vis_ConnectSetTopology (connectp,i,shape,3,0,0);
      vis_ConnectElemNode (connect,i,&nix,ix);
      vis_ConnectElemNum (connect,SYS_EDGE,i,&ned);
                   /* look up edge in hashtable to retrieve midside node */ 
      for(j = 1; j <= ned; j++) {
         vis_ConnectElemCon (connect,SYS_EDGE,i,j,&nex,iex);
         if(iex[0] > iex[1]) {
            ixs = iex[0];
            iex[0] = iex[1];
            iex[1] = ixs;
         }
         vsy_IntVHashLookup (ivh,iex,&nid);
         ix[nix+j-1] = nid;
      }
      vis_ConnectSetElemNode (connectp,i,ix);
   }
   vis_ConnectWrite (connectp,SYS_NASTRAN_BULKDATA,"exam24a.bdf");

                   /* destroy objects */ 
   vis_ConnectEnd (connect);
   vis_ConnectEnd (connectp);
   vis_GroupEnd (groupedge);
   vsy_IntVHashEnd (ivh);
   return 0;
}

Table of Contents

25.7 Example 25, Node Results Data Using State

This example illustrates the use of a State object to manage a vector quantity at nodes. A simple vector field is defined at 4 nodes. Using the vis_StateDef function, the parent entity type is defined as SYS_NODE, the child type is SYS_NONE and the data type is VIS_VECTOR. The vector data is entered for each node using vis_StateSetData. The derived quantity is set to VIS_VECTOR_MAG which specifies that all subsequent queries of the state data return this derived quantity until changed by another call to vis_StateSetDerive. The vector magnitude is queried and printed for each node using vis_StateData. Then the derived quantity is set to VIS_VECTOR and the primitive vector data is queried and printed for a set of nodes. Finally, the minimum and maximum values of the vector field are queried and printed.

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

#define MAX_NODE 4

static Vfloat v[MAX_NODE][3] = {
   {3.,2.,0.}, {-1.,0.,0.}, {1.,1.,0.}, {2.,-2.,-4.} };

/*----------------------------------------------------------------------
                      Generate node vector state object
----------------------------------------------------------------------*/
int
main()
{
   vis_State *state;
   Vint i;
   Vfloat vs[9], extent[2][3];
   Vint ix[3];
   Vint ids[2][3], nos[2][3];

                   /* create node state object */ 
   state = vis_StateBegin ();
   vis_StateDef (state,MAX_NODE,SYS_NODE,SYS_NONE,VIS_VECTOR);

                   /* load vector data */
   for(i = 0; i < MAX_NODE; i++) {
      vis_StateSetData (state,i+1,v[i]);
   }
                   /* query derived vector magnitude */
   vis_StateSetDerive (state,VIS_VECTOR_MAG);
   for(i = 1; i <= MAX_NODE; i++) {
      vis_StateData (state,1,&i,vs);
      printf("index= %d, magnitude= %f\n",i,vs[0]);
   }
                   /* query for primitive vector at nodes 2, 3 and 4 */ 
   vis_StateSetDerive (state,VIS_VECTOR);
   ix[0] = 2;
   ix[1] = 3;
   ix[2] = 4;
   vis_StateData (state,3,ix,vs);
   for(i = 0; i < 3; i++) {
      printf("index= %d, vector= %f %f %f\n",ix[i],vs[3*i],vs[3*i+1],vs[3*i+2]);
   }
                   /* query for data extent */ 
   vis_StateExtent (state,NULL,(Vfloat*)extent);
   printf("vector min= %f %f %f\n",extent[0][0],extent[0][1],extent[0][2]);
   printf("vector max= %f %f %f\n",extent[1][0],extent[1][1],extent[1][2]);

                   /* query for data extent and locations */ 
   vis_StateExtentLoc (state,NULL,(Vfloat*)extent,(Vint*)ids,(Vint*)nos);
   printf("vector min= %f %f %f\n",extent[0][0],extent[0][1],extent[0][2]);
   printf("       ids= %d %d %d\n",ids[0][0],ids[0][1],ids[0][2]);
   printf("vector max= %f %f %f\n",extent[1][0],extent[1][1],extent[1][2]);
   printf("       ids= %d %d %d\n",ids[1][0],ids[1][1],ids[1][2]);

                   /* double the values */ 
   vis_StateOperateUnary (state,STATE_MULTIPLYEQUAL,2.,STATE_UNITY,NULL,NULL);

                   /* query for data extent */ 
   vis_StateExtent (state,NULL,(Vfloat*)extent);
   printf("vector min= %f %f %f\n",extent[0][0],extent[0][1],extent[0][2]);
   printf("vector max= %f %f %f\n",extent[1][0],extent[1][1],extent[1][2]);

                   /* take the absolute values */
   vis_StateOperateUnary (state,STATE_EQUAL,1.,STATE_ABS,state,NULL);

                   /* query and print all vector data */ 
   for(i = 1; i <= MAX_NODE; i++) {
      vis_StateData (state,1,&i,vs);
      printf("index= %d, vector= %f %f %f\n",ix[0],vs[0],vs[1],vs[2]);
   }
                   /* end objects */ 
   vis_StateEnd (state);
   return 0;
}

Table of Contents

25.8 Example 25a, Node History Results Data using History

This example illustrates the use of a History object to manage a vector quantity at a set of 2 nodes over 5 solution steps. Using the vis_HistoryDef function, the number of steps and the number of parent entities are defined. The parent entity type is defined as SYS_NODE, the child type is SYS_NONE and the data type is VIS_VECTOR. The vector data is entered for each node at each step using vis_HistorySetData. The index and step numbers are queried using vis_HistoryIndices and vis_HistorySteps respectively. The vector data is queried using vis_HistoryData and printed. The vector data extent for all steps and nodes is returned using vis_HistoryExtent. The derived quantity is set to VIS_VECTOR_MAG which specifies that all subsequent queries of the history data return this derived quantity until changed by another call to vis_HistorySetDerive. The vector magnitude is queried and printed for each node using vis_HistoryData.

The down sampling rankings are computed using vis_HistorySample. Each step rank is accessed and printed using vis_HistoryGetRank. The cutoff rank to represent the last 4 time steps with 3 points is determined using vis_HistoryCutoffRank.

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

#define MAX_NODE 2
#define MAX_STEP 5

                   /* history data */ 
static Vfloat v[MAX_STEP][MAX_NODE][3] = {
   {{3.0,2.0,0.}, {-1.0,0.,0.}},
   {{3.1,2.2,0.}, {-1.1,0.,0.}},
   {{3.2,2.4,0.}, {-1.2,0.,0.}},
   {{3.3,2.2,0.}, {-1.3,0.,0.}},
   {{3.4,2.0,0.}, {-1.4,0.,0.}} };

                   /* node indices */ 
static Vint ind[MAX_NODE] = {
    1801,2102 };

                   /* step numbers */ 
static Vint stp[MAX_STEP] = {
    10,20,30,40,50 };
                   /* independent step values */ 
static Vfloat t[MAX_STEP] = {
    1.,3.,5.,7.,9. };

/*----------------------------------------------------------------------
                      Generate node vector history object
----------------------------------------------------------------------*/
int
main()
{
   Vint i, j;
   vis_History *history;
   Vint istep, index;
   Vfloat vs[3], vmag, ts;
   Vfloat extent[2][3];
   Vint nument, numstp;
   Vint stpnum[MAX_STEP], indval[MAX_NODE];
   Vfloat sval[MAX_STEP];
   Vint rank, cutoffrank;

                   /* create node history object */ 
   history = vis_HistoryBegin ();
   vis_HistoryDef (history,MAX_STEP,MAX_NODE,SYS_NODE,SYS_NONE,VIS_VECTOR);

                   /* set vector and independent data values */
   for(j = 0; j < MAX_STEP; j++) {
      vis_HistorySetIndep (history,stp[j],t[j]);
      for(i = 0; i < MAX_NODE; i++) {
         vis_HistorySetData (history,stp[j],ind[i],v[j][i]);
      }
   }
                   /* get vector and independent value data */
   vis_HistorySteps (history,&numstp,stpnum);
   vis_HistoryIndices (history,&nument,indval);
   for(j = 0; j < numstp; j++) {
      vis_HistoryIndep (history,stpnum[j],&ts);
      for(i = 0; i < nument; i++) {
         vis_HistoryData (history,stpnum[j],1,&indval[i],vs);
         printf("istep= %d, index= %d, vector= %f %f %f, indep= %f\n",
                 stpnum[j],indval[i],vs[0],vs[1],vs[2],ts);
      }
   }
                   /* query for data extent */
   vis_HistoryExtent (history,(Vfloat*)extent);
   printf("vector min= %f %f %f\n",extent[0][0],extent[0][1],extent[0][2]);
   printf("vector max= %f %f %f\n",extent[1][0],extent[1][1],extent[1][2]);

                   /* compute vector magnitude */ 
   vis_HistorySetDerive (history,VIS_VECTOR_MAG);
   istep = 20;
   index = 1801;
   vis_HistoryData (history,istep,1,&index,&vmag);
   printf("istep= %d, index= %d, mag= %f\n",istep,index,vmag);

                   /* get vector magnitude for node 1801 for all steps */
   vis_HistoryDataSteps (history,1,&index,sval);
   for(i = 0; i < numstp; i++) {
      printf("istep= %d, mag= %f\n",stpnum[i],sval[i]);
   }
                   /* generate sampling rank */ 
   vis_HistorySample (history);
                   /* query ranking */ 
   for(i = 0; i < numstp; i++) {
      vis_HistoryGetRank (history,stpnum[i],&rank);
      printf("istep= %d, rank= %d\n",stpnum[i],rank);
   }
                   /* determine cutoff rank to retain 3 points
                      for last 4 steps */ 
   vis_HistoryCutoffRank (history,stpnum[1],stpnum[4],3,&cutoffrank);
   printf("cutoffrank= %d\n",cutoffrank);

                   /* traverse steps, retain first and last points
                      and any rank greater than cutoff */ 
   for(i = 1; i <= 4; i++) {
      vis_HistoryGetRank (history,stpnum[i],&rank);
      if(i == 1 || i == 4 || rank > cutoffrank) {
         printf("draw step %d\n",stpnum[i]);
      } else {
         printf("ignore step %d\n",stpnum[i]);
      }
   }
                   /* end objects */ 
   vis_HistoryEnd (history);
   return 0;
}

Table of Contents

25.9 Example 25b, Element Node Scalar Section Results using History

This example illustrates the use of a History object to manage element node scalar section data at 2 elements with sections over 5 solution steps. Using the vis_HistoryDef function, the number of steps and the number of parent entities are defined. The parent entity type is defined as SYS_ELEM, the child type is SYS_NODE and the data type is VIS_SCALAR. In the case of element section data, the number of sections at each element must be specified using vis_HistorySetDataSect before the data is entered. The step independent value and element scalar data is entered for each element at all sections at each step using vis_HistorySetIndep and vis_HistorySetData.

To query the data, the number of steps and number of element indices are first queried using vis_HistoryNumSteps and vis_HistoryNumIndices. The specific section to return data for is set using vis_HistorySetSection. In this case, the first section. A double loop is entered over the steps and elements to query and print the data.

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

#define MAX_ELEM 4
#define NUM_ELEM 2
#define NUM_STEP 5

                   /* element shape */ 
static Vint shap[MAX_ELEM] = {
   VIS_SHAPEHEX, VIS_SHAPEQUAD, VIS_SHAPEWED, VIS_SHAPETRI };

                   /* elem indices */ 
static Vint ind[NUM_ELEM] = {
    1, 4 };
                   /* number of sections */ 
static Vint sec[NUM_ELEM] = {
    1, 3};
                   /* step numbers */ 
static Vint stp[NUM_STEP] = {
    10,20,30,40,50 };
                   /* independent step values */ 
static Vfloat t[NUM_STEP] = {
    1.,3.,5.,7.,9. };

/*----------------------------------------------------------------------
                      Element Node Scalar Section Results Using History
----------------------------------------------------------------------*/
int
main()
{
   Vint i, j, k, n;
   vis_Connect *connect;
   vis_GridFun *gridfun;
   vis_History *history;
   Vint istep, index, in;
   Vfloat dat[12];
   Vfloat ss[8], ts;
   Vint nument, numstp;
   Vint nix;

                   /* create element model */
   connect = vis_ConnectBegin ();
   vis_ConnectDef (connect,0,MAX_ELEM);
                   /* define element topologies */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetTopology (connect,i+1,shap[i],2,0,0);
   }
   gridfun = vis_GridFunBegin ();
   vis_ConnectGridFun (connect,gridfun);

                   /* create element node scalar history object */ 
   history = vis_HistoryBegin ();
   vis_HistoryDef (history,NUM_STEP,NUM_ELEM,SYS_ELEM,SYS_NODE,VIS_SCALAR);
   vis_HistorySetObject (history,VIS_GRIDFUN,gridfun);

                   /* set number of sections for each element */ 
   for(i = 0; i < NUM_ELEM; i++) {
      vis_HistorySetDataSect (history,ind[i],sec[i]);
   }
                   /* set scalar and independent data values */
                   /*  1  digit is element node index
                      10  digit is section index
                     100  digit is element index
                    1000  digit is time step index  */
   for(j = 0; j < NUM_STEP; j++) {
      vis_HistorySetIndep (history,stp[j],t[j]);
      for(i = 0; i < NUM_ELEM; i++) {
         vis_GridFunNumElemNode (gridfun,ind[i],&nix);
         in = 0;
         for(n = 0; n < sec[i]; n++) {
            for(k = 0; k < nix; k++) {
               dat[in++] = (j+1)*1000 + ind[i]*100 + (n+1)*10 + k+1;
            }
         }
         vis_HistorySetData (history,stp[j],ind[i],dat);
      }
   }
                   /* get scalar and independent value data */
                   /* query for number of steps and indices */
   vis_HistoryNumSteps (history,&numstp);
   printf("numstp= %d\n",numstp);
   vis_HistoryNumIndices (history,&nument);
   printf("nument= %d\n",nument);
                   /* set section */
   vis_HistorySetSection (history,1);
                   /* loop through steps */ 
   for(j = 1; j <= numstp; j++) {
      vis_HistoryGetStep (history,j,&istep);
      vis_HistoryIndep (history,istep,&ts);
      printf("istep= %d, indep= %f\n",istep,ts);
                   /* loop through indices */ 
      for(i = 1; i <= nument; i++) {
         vis_HistoryGetIndex (history,i,&index);
         vis_HistoryData (history,istep,1,&index,ss);
         vis_GridFunNumElemNode (gridfun,index,&nix);
         printf("index= %d\n",index);
                   /* loop through element nodes */ 
         for(k = 0; k < nix; k++) {
            printf("scalar= %f\n",ss[k]);
         }
      }
   }
                   /* end objects */ 
   vis_HistoryEnd (history);
   vis_GridFunEnd (gridfun);
   vis_ConnectEnd (connect);
   return 0;
}

Table of Contents

25.10 Example 25c, Element Face and Face Node Results using State

This example illustrates the use of a State object to manage element face and element face node scalar data. The State object will handle both element face and element edge based data. In these cases the parent type is set to either SYS_FACE or SYS_EDGE respectively. If the data is at face nodes or edge nodes, the subtype is set to SYS_NODE, otherwise it is set to SYS_NONE. Using the vis_StateDef function, the number of number of elements and entity location is defined for vector data. In the case of element entity data, the number of entities at each element must be specified using vis_StateSetDataEnt before the data is entered. The data may be queried using vis_StateData to get the data for all faces of an element or using vis_StateDataElemEnt to get data for a specified element face.

The case of element face node data requires that a GridFun object be set in State since this type of data requires explicit knowledge of element topology, order, etc.

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

#define MAX_ELEM 4
#define NUM_ELEM 2

                   /* element shape */ 
static Vint shap[MAX_ELEM] = {
   VIS_SHAPEHEX, VIS_SHAPEQUAD, VIS_SHAPEWED, VIS_SHAPETRI };

                   /* elem indices */ 
static Vint ind[NUM_ELEM] = {
    1, 4 };
static Vint numno[NUM_ELEM] = {
    2, 1 };
static Vint no[NUM_ELEM][2]  = {
    {3, 4}, {1, 0} };

/*----------------------------------------------------------------------
                      Element Face and Face Node Results Using State
----------------------------------------------------------------------*/
int
main()
{
   Vint i, j, k, n;
   vis_Connect *connect;
   vis_GridFun *gridfun;
   vis_State *state, *statefn;
   Vfloat s[24];
   Vint ndat, nloc, nsec;
   Vint shape, maxi, maxj, nfx;

                   /* create element model */
   connect = vis_ConnectBegin ();
   vis_ConnectDef (connect,0,MAX_ELEM);
                   /* define element topologies */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetTopology (connect,i+1,shap[i],2,0,0);
   }
   gridfun = vis_GridFunBegin ();
   vis_ConnectGridFun (connect,gridfun);

                   /* create element face vector state object */ 
   state = vis_StateBegin ();
   vis_StateDef (state,MAX_ELEM,SYS_FACE,SYS_NONE,VIS_VECTOR);
   vis_StateSetObject (state,VIS_GRIDFUN,gridfun);

                   /* set number of faces and face numbers for each element */ 
   for(i = 0; i < NUM_ELEM; i++) {
      vis_StateSetDataEnt (state,ind[i],numno[i],no[i]);
   }
                   /* manufacture and set data */
   for(i = 0; i < NUM_ELEM; i++) {
      s[0] = no[i][0];
      s[1] = s[0] + .01;
      s[2] = s[0] + .02;

      s[3] = no[i][1];
      s[4] = s[3] + .01;
      s[5] = s[3] + .02;
      vis_StateSetData (state,ind[i],s);
   }
                   /* get data */
   for(i = 0; i < NUM_ELEM; i++) {
      vis_StateData (state,1,&ind[i],s);
      vis_StateDataNum (state,ind[i],&ndat,&nloc,&nsec);
      printf("element= %d, data= ",ind[i]);
      for(j = 0; j < ndat; j++) {
         printf(" %e",s[j]);
      }
      printf("\n");
   }
                   /* get data at first element face 4 */ 
   vis_StateDataElemEnt (state,SYS_FACE,ind[0],4,s);
   printf("element= %d, data= %e %e %e\n",ind[0],s[0],s[1],s[2]);

   vis_StateSetDerive (state,VIS_VECTOR_MAG);
   for(i = 0; i < NUM_ELEM; i++) {
      vis_StateData (state,1,&ind[i],s);
      printf("element= %d, data= %e\n",ind[i],s[0]);
   }
                   /* test element face node state */ 
   statefn = vis_StateBegin ();
   vis_StateDef (statefn,MAX_ELEM,SYS_FACE,SYS_NODE,VIS_VECTOR);
   vis_StateSetObject (statefn,VIS_GRIDFUN,gridfun);
                   /* set number of faces and face numbers for each element */ 
   for(i = 0; i < NUM_ELEM; i++) {
      vis_StateSetDataEnt (statefn,ind[i],numno[i],no[i]);
   }
                   /* manufacture and set data */
                   /* loop over elements */
   for(i = 0; i < NUM_ELEM; i++) {
      n = 0;
                   /* loop over faces */
      for(j = 0; j < numno[i]; j++) {
         vis_ConnectElemTopo (connect,SYS_FACE,ind[i],no[i][j],
                              &shape,&maxi,&maxj);
                   /* compute number of face nodes */ 
         if(shape == SYS_SHAPEQUAD) {
            nfx = 4;
         } else {
            nfx = 3;
         }
                   /* set data at each face node */
         for(k = 0; k < 3*nfx; k++) {
            s[n++] = ind[i] + no[i][j] + k;
         }
      }
      vis_StateSetData (statefn,ind[i],s);
   }
                   /* get data at first element face 4 */ 
   vis_StateDataElemEnt (statefn,SYS_FACE,ind[0],4,s);
   printf("element= %d\n",ind[0]);
   for(k = 0; k < 4; k++) {
      printf("k= %d, data= %e %e %e\n",k,s[3*k],s[3*k+1],s[3*k+2]);
   }

   vis_StateEnd (state);
   vis_StateEnd (statefn);
   vis_GridFunEnd (gridfun);
   vis_ConnectEnd (connect);
   return 0;
}

Table of Contents

25.11 Example 26, Element and Node Results Data

This example uses the same finite element model introduced in Example 23 and illustrates the use of two State objects to manage and map tensor results data at element centroids and nodes. Once the finite element domain is defined as in Example 23, the Connect object is queried for its grid functions. A GridFun object is a required attribute for any State object which is used to map results data. The GridFun object is used by State objects for any domain related queries which must be made during a map operation. Two State objects are instanced, one to hold the original element centroidal data, and another to hold the mapped node data. The element tensor data is set using vis_StateSetData. Next, the principal values and principal directions are queried and printed. The derived type is then set back to the full tensor and the element data is mapped to nodes using vis_StateMap. Once the tensor data is mapped to nodes, the Von Mises "stress" may be queried at the nodes by setting the derived quantity to VIS_TENSOR_VONMISES and querying the data at nodes using vis_StateData. Several other derived tensor quantities may be queried by changing the derived quantity type in vis_StateSetDerive.

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

#define MAX_ELEM  3
#define MAX_NODE 14
                   /* element model data */ 
static Vint conn[MAX_ELEM][8] = {
   {1, 2, 6, 5, 9,10,13,12},
   {2, 3, 7, 6,10,11,14,13},
   {3, 4, 8, 7, 0, 0, 0, 0} };

static Vint shap[MAX_ELEM] = {
   VIS_SHAPEHEX, VIS_SHAPEHEX, VIS_SHAPEQUAD };

static Vfloat coords[MAX_NODE][3] = {
   {0.,0.,0.},  {1.,0.,0.},  {2.,0.,0.},  {3.,0.,0.},
   {0.,1.,0.},  {1.,1.,0.},  {2.,1.,0.},  {3.,1.,0.},
   {0.,0.,1.},  {1.,0.,1.},  {2.,0.,1.},
   {0.,1.,1.},  {1.,1.,1.},  {2.,1.,1.} };

                   /* element tensor data */ 
static Vfloat selem[3][6] = {
   { 1., -2., 3., .1, .2, .3},
   { 1.2,-2.1,3.5,.12,.21,.31},
   { 1.3,-2.2,3.4,.13,.24,.33} };

void
print_nodestate(vis_State *state, Vchar *stg);

/*----------------------------------------------------------------------
                      Element and Node Tensor Data
----------------------------------------------------------------------*/
int
main()
{
   vis_Connect *connect;
   vis_State   *stateelem, *statenode, *stateelemnode;
   vis_GridFun *gf;

   Vint i;
   Vfloat s[6], tm[3][3];
   Vfloat extent[2][6];
   Vint ids[2][6], nos[2][6];
   Vfloat se[8];

                   /* create connect object */
   connect = vis_ConnectBegin ();
   vis_ConnectDef (connect,MAX_NODE,MAX_ELEM);

                   /* set topologies */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetTopology (connect,i+1,shap[i],2,0,0);
   }
                   /* set element node connectivity */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetElemNode (connect,i+1,conn[i]);
   }
                   /* set node coordinates */
   for(i = 0; i < MAX_NODE; i++) {
      vis_ConnectSetCoords (connect,i+1,coords[i]);
   }

                   /* create a grid function object */ 
   gf = vis_GridFunBegin ();
   vis_ConnectGridFun (connect,gf);

                   /* create state object for element data */
   stateelem = vis_StateBegin ();
   vis_StateDef (stateelem,MAX_ELEM,SYS_ELEM,SYS_NONE,VIS_TENSOR);
   vis_StateSetObject (stateelem,VIS_GRIDFUN,gf);

                   /* create state object for node data */
   statenode = vis_StateBegin ();
   vis_StateDef (statenode,MAX_NODE,SYS_NODE,SYS_NONE,VIS_TENSOR);

                   /* load element tensor */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_StateSetData (stateelem,i+1,selem[i]);
   }
                   /* compute principal values and directions */ 
   vis_StateSetDerive (stateelem,VIS_TENSOR_PRINC);
   for(i = 1; i <= MAX_ELEM; i++) {
      vis_StateData (stateelem,1,&i,s);
      printf("elem= %d, principal stresses= %f %f %f\n",i,s[0],s[1],s[2]);
   }
   vis_StateSetDerive (stateelem,VIS_TENSOR_PRINCDIRCOS);
   for(i = 1; i <= MAX_ELEM; i++) {
      vis_StateData (stateelem,1,&i,(Vfloat*)tm);
      printf("elem= %d, principal vector 1= %f %f %f\n",i,
              tm[0][0],tm[0][1],tm[0][2]);
      printf("elem= %d, principal vector 2= %f %f %f\n",i,
              tm[1][0],tm[1][1],tm[1][2]);
      printf("elem= %d, principal vector 3= %f %f %f\n",i,
              tm[2][0],tm[2][1],tm[2][2]);
   }
                   /* set derived quantity back to full tensor */ 
   vis_StateSetDerive (stateelem,VIS_TENSOR);

                   /* map element data to nodes */ 
   vis_StateMap (statenode,stateelem,NULL);

                   /* set derived quantity to Von Mises stress */ 
   vis_StateSetDerive (statenode,VIS_TENSOR_VONMISES);

                   /* query for Von Mises stress at nodes */
   for(i = 1; i <= MAX_NODE; i++) {
      vis_StateData (statenode,1,&i,s);
      printf("node= %d, Von Mises stress= %f\n",i,s[0]);
   }
                   /* create state object for element node data */
   stateelemnode = vis_StateBegin ();
   vis_StateDef (stateelemnode,MAX_ELEM,SYS_ELEM,SYS_NODE,VIS_TENSOR);
   vis_StateSetObject (stateelemnode,VIS_GRIDFUN,gf);

                   /* map node data to element nodes */ 
   vis_StateSetDerive (statenode,VIS_TENSOR);
   vis_StateMap (stateelemnode,statenode,NULL);

                   /* find extremes and locations */ 
   vis_StateExtentLoc(stateelemnode,NULL,(Vfloat*)extent,(Vint*)ids,(Vint*)nos);
   for(i = 0; i < 6; i++) {
      printf("min= %f ids= %d nos= %d, max= %f ids= %d nos= %d\n",
              extent[0][i],ids[0][i],nos[0][i],
              extent[1][i],ids[1][i],nos[1][i]);
   }
                   /* gather element face from node state */ 
   vis_StateSetObject (statenode,VIS_GRIDFUN,gf);
   vis_StateSetDerive (statenode,VIS_TENSOR_VONMISES);
   vis_StateDataElemEnt (statenode,SYS_FACE,1,2,se);
   printf("Element 1, face 2 from node state\n");
   for(i = 0; i < 4; i++) {
      printf("Von Mises stress= %f\n",se[i]);
   }
                   /* gather element face from element node state */ 
   vis_StateSetDerive (stateelemnode,VIS_TENSOR_VONMISES);
   vis_StateDataElemEnt (stateelemnode,SYS_FACE,1,2,se);
   printf("Element 1, face 2 from element node state\n");
   for(i = 0; i < 4; i++) {
      printf("Von Mises stress= %f\n",se[i]);
   }
                   /* now test some different node mapping options */ 
   vis_StateSetDerive (statenode,VIS_TENSOR);

                   /* strict minimum */ 
   vis_StateSetParami (statenode,STATE_MAPNODE,STATE_MAPMIN);
   vis_StateMap (statenode,stateelem,NULL);
   print_nodestate (statenode,"Map Minimum");

                   /* minimum based on absolute value */ 
   vis_StateSetParami (statenode,STATE_MAPNODE,STATE_MAPABSMIN);
   vis_StateMap (statenode,stateelem,NULL);
   print_nodestate (statenode,"Map Absolute Value Minimum");

                   /* strict maximum */
   vis_StateSetParami (statenode,STATE_MAPNODE,STATE_MAPMAX);
   vis_StateMap (statenode,stateelem,NULL);
   print_nodestate (statenode,"Map Maximum");

                   /* maximum based on absolute value */
   vis_StateSetParami (statenode,STATE_MAPNODE,STATE_MAPABSMAX);
   vis_StateMap (statenode,stateelem,NULL);
   print_nodestate (statenode,"Map Absolute Value Maximum");

                   /* min-max difference */ 
   vis_StateSetParami (statenode,STATE_MAPNODE,STATE_MAPDIFF);
   vis_StateMap (statenode,stateelem,NULL);
   print_nodestate (statenode,"Map Difference");

                   /* end objects */ 
   vis_ConnectEnd (connect);
   vis_StateEnd (stateelem);
   vis_StateEnd (statenode);
   vis_StateEnd (stateelemnode);
   vis_GridFunEnd (gf);
   return 0;
}

void
print_nodestate(vis_State *state, Vchar *stg)
{
   Vint i;
   Vfloat s[6];

   printf("%s\n",stg);
   for(i = 1; i <= MAX_NODE; i++) {
      vis_StateData (state,1,&i,s);
      printf("node= %2d, sxx= %10f,  syy= %10f,  szz= %10f\n",i,s[0],s[1],s[2]);
      printf("          sxy= %10f,  syz= %10f,  szx= %10f\n",  s[3],s[4],s[5]);
   }
}

Table of Contents

25.12 Example 26a, Element Face Node Data Using ElemDat

This example uses the same finite element model introduced in Example 23 and illustrates the use of a ElemDat object for storing and retrieving element face based data. Once the finite element domain is defined as in Example 23, the Connect object is queried for its grid functions. A GridFun object is a required attribute for any ElemDat object and also proves useful for querying the finite element model for printing the element data. The ElemDat object is instanced and defined to hold element face node scalar data. This data could represent a distributed pressure load that varies across each element face. The data is stored using vis_ElemDatSetData at the front faces (face number 2) of the hex elements (elements 1 and 2) and varies along the x coordinate (from 1. at x=0. to 2. at x=1. to 1. at x=2.). The element faces at which data has been set may be queried by generating a list of element faces using vis_ElemDatIdTran. This IdTran is then used to control a loop for accessing and printing the data stored in the ElemDat object.

Then an imaginary component is added to the front face of element 2. Use vis_ElemDatSetComplexMode to indicate that the imaginary component is begin set. In order access the real and imaginary parts simultaneously, vis_ElemDatSetComplexMode must be called with SYS_COMPLEX_REALIMAGINARY.

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

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

#define MAX_ELEM  3
#define MAX_NODE 14

static Vint conn[MAX_ELEM][8] = {
   {1, 2, 6, 5, 9,10,13,12},
   {2, 3, 7, 6,10,11,14,13},
   {3, 4, 8, 7, 0, 0, 0, 0} };
static Vint shap[MAX_ELEM] = {
   VIS_SHAPEHEX, VIS_SHAPEHEX, VIS_SHAPEQUAD };
static Vfloat coords[MAX_NODE][3] = {
   {0.,0.,0.},  {1.,0.,0.},  {2.,0.,0.},  {3.,0.,0.},
   {0.,1.,0.},  {1.,1.,0.},  {2.,1.,0.},  {3.,1.,0.},
   {0.,0.,1.},  {1.,0.,1.},  {2.,0.,1.},
   {0.,1.,1.},  {1.,1.,1.},  {2.,1.,1.} };

/*----------------------------------------------------------------------
                      Element Face Node Data
----------------------------------------------------------------------*/
int
main()
{
   vis_Connect *connect;
   vis_ElemDat *elemdat;
   vis_IdTran *idtran;
   vis_GridFun *gf;

   Vint i, j, k, m;
   Vfloat p[8];
   Vint num, nix, ix[4], flag;

                   /* create connect object */
   connect = vis_ConnectBegin ();
   vis_ConnectDef (connect,MAX_NODE,MAX_ELEM);

                   /* set topologies */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetTopology (connect,i+1,shap[i],2,0,0);
   }
                   /* set element node connectivity */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetElemNode (connect,i+1,conn[i]);
   }
                   /* set node coordinates */
   for(i = 0; i < MAX_NODE; i++) {
      vis_ConnectSetCoords (connect,i+1,coords[i]);
   }
                   /* create a grid function object */ 
   gf = vis_GridFunBegin ();
   vis_ConnectGridFun (connect,gf);

                   /* create elemdat object for element face node scalars */ 
   elemdat = vis_ElemDatBegin ();
   vis_ElemDatDef (elemdat,MAX_ELEM,SYS_FACE,SYS_NODE,SYS_SCALAR);
   vis_ElemDatSetObject (elemdat,VIS_GRIDFUN,gf);

                   /* set pressure for front face of element 1 */ 
   p[0] = 1.;  p[1] = 2.;  p[2] = 2.;  p[3] = 1.;
   vis_ElemDatSetData (elemdat,1,2,p);
                   /* set pressure for front face of element 2 */ 
   p[0] = 2.;  p[1] = 1.;  p[2] = 1.;  p[3] = 2.;
   vis_ElemDatSetData (elemdat,2,2,p);

                   /* fill idtran with defined element faces */ 
   idtran = vis_IdTranBegin();
   vis_ElemDatIdTran (elemdat,ELEMDAT_SETDATA,idtran);

                   /* loop through defined element faces and print */ 
   vis_IdTranInq (idtran,&num);
   for(i = 1; i <= num; i++) {
      vis_IdTranGetId (idtran,i,&m);
      vis_IdTranGetEnt (idtran,i,&j);
      vis_ElemDatData (elemdat,m,j,p);
      vis_GridFunElemCon (gf,SYS_FACE,m,j,&nix,ix);
      printf("element= %d, face= %d, number of nodes= %d\n",m,j,nix);
      for(k = 0; k < nix; k++) {
         printf("  p(node= %d)= %f\n",ix[k],p[k]);
      }
   }
                   /* now add imaginary data at front face of element 2 */ 
   vis_ElemDatSetComplexMode (elemdat,SYS_COMPLEX_IMAGINARY);
   p[0] = 4.;  p[1] = 3.;  p[2] = 3.;  p[3] = 4.;
   vis_ElemDatSetData (elemdat,2,2,p);
                   /* query overall complex data flag, should be 1 now */ 
   vis_ElemDatGetComplex (elemdat,&flag);
   printf("Complex flag= %d\n",flag);
                   /* get complete complex data, entities have not changed */ 
   vis_ElemDatSetComplexMode (elemdat,SYS_COMPLEX_REALIMAGINARY);
   for(i = 1; i <= num; i++) {
      vis_IdTranGetId (idtran,i,&m);
      vis_IdTranGetEnt (idtran,i,&j);
      vis_ElemDatData (elemdat,m,j,p);
      vis_GridFunElemCon (gf,SYS_FACE,m,j,&nix,ix);
      printf("element= %d, face= %d, number of nodes= %d\n",m,j,nix);
      for(k = 0; k < nix; k++) {
         printf("  p(node= %d)= %f %f(i)\n",ix[k],p[2*k],p[2*k+1]);
      }
   }
                   /* end objects */ 
   vis_ConnectEnd (connect);
   vis_ElemDatEnd (elemdat);
   vis_IdTranEnd (idtran);
   vis_GridFunEnd (gf);
   return 0;
}

Table of Contents

25.13 Example 26b, Element Face Node Normals Using ElemDat

This example illustrates the use of an ElemDat object for computing element face normals. These normals are useful for rendering of element faces with accurate shading. They may also be useful for preparing geometry input for some commercial finite element programs. Element face node normals are computed by averaging contributing normals from adjacent faces across edges except for those cases in which a element face discontinuity is meant to exist. The discontinuities may be determined geometrically by entering a feature angle or topologically by setting a element face branch flag.

A Connect object is generated which holds 5 shell elements. The first shell branches with the curved shell formed by elements 2,3,4 and 5. The ElemDat object is instanced and defined to hold element face node vector data. The function vis_ElemDatSetParamf is used to set a feature angle of 20. degrees. The function vis_ElemDatSetParami is used to enable the determination of an edge existing at a shell branch as a discontinuity in the shell. Element face normals will not be averaged across a discontinuous edge. The actual computation of element face node normals is performed by the function vis_ElemDatNormal. The computed normals are accessed using vis_ElemDatData and printed.

#include <stdio.h>
#include <math.h>
#include "base/base.h"
#include "vis/vis.h"

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

#define MAX_ELEM  5
#define MAX_NODE 12

static Vint conn[MAX_ELEM][4] = {
   {1, 2, 8, 7},
   {3, 4, 6, 5},
   {5, 6, 8, 7},
   {7, 8,10, 9},
   {9,10,12,11} };
static Vfloat coords[MAX_NODE][3];

/*----------------------------------------------------------------------
                      Element Face Node Normals
----------------------------------------------------------------------*/
int
main()
{
   vis_Connect *connect;
   vis_ElemDat *elemdat;
   vis_Group *groupfree;
   vis_IdTran *idtran;
   vis_GridFun *gf;

   Vint i, j, k, m;
   Vfloat p[4][3];
   Vint num, nix, ix[4];
   Vfloat ang;

                   /* create connect object */
   connect = vis_ConnectBegin ();
   vis_ConnectDef (connect,MAX_NODE,MAX_ELEM);

                   /* generate node coordinates */ 
   coords[0][0] = 0.;
   coords[0][1] = 0.;
   coords[0][2] = 1.;

   coords[1][0] = coords[0][0];
   coords[1][1] = 1.;
   coords[1][2] = coords[0][2];
   ang = -40.;
   for(i = 2; i < MAX_NODE; i += 2) {
      coords[i][0] = sin(.017453*ang);
      coords[i][1] = 0.;
      coords[i][2] = 1.-cos(.017453*ang);

      coords[i+1][0] = coords[i][0];
      coords[i+1][1] = 1.;
      coords[i+1][2] = coords[i][2];
      ang += 20.;
   }

                   /* set topologies */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetTopology (connect,i+1,VIS_SHAPEQUAD,2,0,0);
   }
                   /* set element node connectivity */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetElemNode (connect,i+1,conn[i]);
   }
                   /* set node coordinates */
   for(i = 0; i < MAX_NODE; i++) {
      vis_ConnectSetCoords (connect,i+1,coords[i]);
   }
                   /* create a grid function object */ 
   gf = vis_GridFunBegin ();
   vis_ConnectGridFun (connect,gf);

                   /* generate kernel */ 
   vis_ConnectKernel (connect,0);

                   /* free face group */ 
   groupfree = vis_GroupBegin ();
   vis_GroupDef (groupfree,MAX_ELEM,SYS_ELEM,SYS_FACE);
   vis_ConnectFaceGroup (connect,CONNECT_FREE,NULL,groupfree);

                   /* create elemdat object for element face node normals */ 
   elemdat = vis_ElemDatBegin ();
   vis_ElemDatDef (elemdat,MAX_ELEM,SYS_FACE,SYS_NODE,SYS_VECTOR);
   vis_ElemDatSetObject (elemdat,VIS_GRIDFUN,gf);
   vis_ElemDatSetParamf (elemdat,ELEMDAT_FEATUREANGLE,20.);
   vis_ElemDatSetParami (elemdat,ELEMDAT_FEATUREBRANCH,SYS_ON);
   vis_ElemDatNormal (elemdat,groupfree);

                   /* fill idtran with defined element faces */
   idtran = vis_IdTranBegin();
   vis_ElemDatIdTran (elemdat,ELEMDAT_SETDATA,idtran);

                   /* loop through defined faces and print */ 
   vis_IdTranInq (idtran,&num);
   for(i = 1; i <= num; i++) {
      vis_IdTranGetId (idtran,i,&m);
      vis_IdTranGetEnt (idtran,i,&j);
      vis_ElemDatData (elemdat,m,j,(Vfloat*)p);
      vis_GridFunElemCon (gf,SYS_FACE,m,j,&nix,ix);
      printf("element= %d, face= %d, number of nodes= %d\n",m,j,nix);
      for(k = 0; k < nix; k++) {
         printf("  p(node= %d)= %f %f %f\n",ix[k],p[k][0],p[k][1],p[k][2]);
      }
   }
                   /* end objects */ 
   vis_ConnectEnd (connect);
   vis_ElemDatEnd (elemdat);
   vis_GroupEnd (groupfree);
   vis_IdTranEnd (idtran);
   vis_GridFunEnd (gf);
   return 0;
}

Table of Contents

25.14 Example 26c, Averaging Element Node Data within Groups

This example illustrates averaging element node data within two mutually exclusive groups of elements. In general, the averaging of element node data such as stress within a group of homogeneous elements is an important operation for visualization and error estimation. In this example a Connect object is filled with a simple quadrilateral element model consisting of 4 elements. It is assumed that elements 1 and 2 are to be averaged separately from elements 3 and 4. The discontinuous, raw element node data to be averaged is manufactured from the element node coordinates by shrinking the element node coordinates towards the element centroid by 10 percent. The basic averaging loop requires looping over the two disjoint element groups. For each group of elements a Group object is filled with the elements to be averaged. The vis_StateMap function is called to average the raw element node data for the group and fill a working node State with the data averaged at the nodes connected to the elements in the Group. vis_StateMap is called a second time to distribute the averaged nodal data to final element node state. The final averaged element node data is printed.

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

/*
    7-----8-----9
    |     |     |
    |  3  |  4  |
    |     |     |
    4-----5-----6
    |     |     |
    |  1  |  2  |
    |     |     |
    1-----2-----3
*/
#define MAX_ELEM  4
#define MAX_NODE  9

static Vint conn[MAX_ELEM][4] = {
   {1, 2, 5, 4},
   {2, 3, 6, 5},
   {4, 5, 8, 7},
   {5, 6, 9, 8} };
static Vfloat coords[MAX_NODE][3] = {
   {0.,0.,0.},  {1.,0.,0.},  {2.,0.,0.},
   {0.,1.,0.},  {1.,1.,0.},  {2.,1.,0.},
   {0.,2.,0.},  {1.,2.,0.},  {2.,2.,0.} };

                   /* group 1, elements 1,2;  group 2, elements 3,4 */ 
static Vint elemgroup[2][2] = {
   {1, 2},
   {3, 4} };

/*----------------------------------------------------------------------
                      Element and Node Tensor Data
----------------------------------------------------------------------*/
int
main()
{
   vis_Connect *connect;
   vis_State   *stateraw, *statenode, *stateave;
   vis_GridFun *gf;
   vis_Group *group;

   Vint i, j, k;
   Vint nix, ix[4];
   Vfloat s[4][3];
   Vfloat x[4][3], xc[3];

                   /* create connect object */
   connect = vis_ConnectBegin ();
   vis_ConnectDef (connect,MAX_NODE,MAX_ELEM);

                   /* set topology and element node connectivity */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetTopology (connect,i+1,SYS_SHAPEQUAD,2,0,0);
      vis_ConnectSetElemNode (connect,i+1,conn[i]);
   }
                   /* set node coordinates */
   for(i = 0; i < MAX_NODE; i++) {
      vis_ConnectSetCoords (connect,i+1,coords[i]);
   }
                   /* create a grid function object */ 
   gf = vis_GridFunBegin ();
   vis_ConnectGridFun (connect,gf);

                   /* create state object for original raw data */
   stateraw = vis_StateBegin ();
   vis_StateDef (stateraw,MAX_ELEM,SYS_ELEM,SYS_NODE,VIS_VECTOR);
   vis_StateSetObject (stateraw,VIS_GRIDFUN,gf);

                   /* fill raw state with element shrink coordinates */ 
                   /* to create a discontinuity across all elements */
   for(i = 1; i <= MAX_ELEM; i++) {
      vis_ConnectElemNode (connect,i,&nix,ix);
      vis_ConnectCoords (connect,nix,ix,x);
                   /* compute element centroid */ 
      for(k = 0; k < 3; k++) {
         xc[k] = 0.;
         for(j = 0; j < nix; j++) {
            xc[k] += x[j][k];
         }
         xc[k] /= nix;
      }
                   /* shrink coordinates toward centroid by 10 percent */ 
      for(k = 0; k < 3; k++) {
         for(j = 0; j < nix; j++) {
            x[j][k] = x[j][k] - .1*(x[j][k]-xc[k]);
         }
      }
      vis_StateSetData (stateraw,i,(Vfloat*)x);
   }
                   /* print raw element node data */
   for(i = 1; i <= MAX_ELEM; i++) {
      vis_StateData (stateraw,1,&i,(Vfloat*)s);
      vis_ConnectElemNode (connect,i,&nix,ix);
      printf("raw data\n");
      for(j = 0; j < nix; j++) {
         printf("elem= %d, node=%d, data= %e %e %e\n",
                 i,ix[j],s[j][0],s[j][1],s[j][2]);
      }
   }
                   /* create working state object for node data */
   statenode = vis_StateBegin ();
   vis_StateDef (statenode,MAX_NODE,SYS_NODE,SYS_NONE,VIS_VECTOR);

                   /* create working element group */
   group = vis_GroupBegin ();
   vis_GroupDef (group,MAX_ELEM,SYS_ELEM,SYS_NONE);

                   /* create state object for final averaged data */
   stateave = vis_StateBegin ();
   vis_StateDef (stateave,MAX_ELEM,SYS_ELEM,SYS_NODE,VIS_VECTOR);
   vis_StateSetObject (stateave,VIS_GRIDFUN,gf);

                   /* loop through mutually exclusive groups of elements */
   for(j = 0; j < 2; j++) {
                   /* fill group with elements */ 
      vis_GroupClear (group);
      for(i = 0; i < 2; i++) {
         vis_GroupSetIndex (group,elemgroup[j][i],1);
      }
                   /* average data within element group */
      vis_StateMap (statenode,stateraw,group);
                   /* distribute averaged node data to element nodes */
      vis_StateMap (stateave,statenode,group);
   }
                   /* print averaged element node data */ 
   for(i = 1; i <= MAX_ELEM; i++) {
      vis_StateData (stateave,1,&i,(Vfloat*)s);
      vis_ConnectElemNode (connect,i,&nix,ix);
      printf("averaged data\n");
      for(j = 0; j < nix; j++) {
         printf("elem= %d, node=%d, data= %e %e %e\n",
                 i,ix[j],s[j][0],s[j][1],s[j][2]);
      }
   }
                   /* end objects */ 
   vis_ConnectEnd (connect);
   vis_GroupEnd (group);
   vis_StateEnd (stateraw);
   vis_StateEnd (statenode);
   vis_StateEnd (stateave);
   vis_GridFunEnd (gf);
   return 0;
}

Table of Contents

25.15 Example 26d, Computing Gradient of Normal Stress

This example illustrates computing gradient of stress normal to faces within solid elements. A single linear hexahedral solid element is defined with a linear varying direct stress field in each of the Cartesian coordinate directions. Several steps are involved in this computation. First a free face group is generated using vis_ConnectFaceGroup and face normals at each node on each free face are computed using vis_ElemDatNormal. Then for each free face and for each node on the free face, each component of the stress is extracted for each node on the element connected to the free face and the gradient vector of the stress component is computed using vis_ThresholdComputeGrad. The gradient vector is projected to the node normal and its magnitude in this direction is printed.

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

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

#define MAX_ELEM  1
#define MAX_NODE  8

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

static Vfloat coords[MAX_NODE][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.} };

/*----------------------------------------------------------------------
                      Computing Gradient of Normal Stress
----------------------------------------------------------------------*/
int
main()
{
   vis_Connect *connect;
   vis_ElemDat *elemdat;
   vis_Group *groupfree;
   vis_GridFun *gf;
   vis_State *state;
   vis_Threshold *threshold;

   Vint i, j, k, m, n;
   Vfloat x[8][3];
   Vfloat stress[8][6];
   Vfloat s[8][6], sn[8];
   Vint nix, ix[8];
   Vfloat v[4][3];
   Vint flags, nfaces, nifx, jfx[4], nd;
   Vint shape, maxi, maxj, maxk;
   Vfloat sng[8][3], grad;

                   /* create connect object */
   connect = vis_ConnectBegin ();
   vis_ConnectDef (connect,MAX_NODE,MAX_ELEM);

                   /* set node coordinates */ 
   for(i = 0; i < MAX_NODE; i++) {
      vis_ConnectSetCoords (connect,i+1,coords[i]);
   }
                   /* set topologies */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetTopology (connect,i+1,VIS_SHAPEHEX,2,0,0);
   }
                   /* set element node connectivity */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetElemNode (connect,i+1,conn[i]);
   }
                   /* create a grid function object */ 
   gf = vis_GridFunBegin ();
   vis_ConnectGridFun (connect,gf);

                   /* generate kernel */ 
   vis_ConnectKernel (connect,0);

                   /* create state of global stress data */ 
   state = vis_StateBegin ();
   vis_StateDef (state,MAX_ELEM,SYS_ELEM,SYS_NODE,SYS_TENSOR);
   vis_StateSetObject (state,VIS_GRIDFUN,gf);
                   /* generated stress has gradients of 2,3,4 in x,y,z */ 
   for(i = 0; i < MAX_NODE; i++) {
      stress[i][0] = 2.*coords[i][0];
      stress[i][1] = 3.*coords[i][1];
      stress[i][2] = 4.*coords[i][2];
      stress[i][3] = 0.;
      stress[i][4] = 0.;
      stress[i][5] = 0.;
   }
   vis_StateSetData (state,1,(Vfloat*)stress);

                   /* free face group */ 
   groupfree = vis_GroupBegin ();
   vis_GroupDef (groupfree,MAX_ELEM,SYS_ELEM,SYS_FACE);
   vis_ConnectFaceGroup (connect,CONNECT_FREE,NULL,groupfree);

                   /* create elemdat object for element face normals */ 
   elemdat = vis_ElemDatBegin ();
   vis_ElemDatDef (elemdat,MAX_ELEM,SYS_FACE,SYS_NODE,SYS_VECTOR);
   vis_ElemDatSetObject (elemdat,VIS_GRIDFUN,gf);
   vis_ElemDatSetParamf (elemdat,ELEMDAT_FEATUREANGLE,20.);
   vis_ElemDatSetParami (elemdat,ELEMDAT_FEATUREBRANCH,SYS_ON);
   vis_ElemDatNormal (elemdat,groupfree);

                   /* instance a Threshold object */ 
   threshold = vis_ThresholdBegin();

                   /* compute normal stress gradient on free face nodes */
   for(i = 1; i <= MAX_ELEM; i++) {
      vis_GroupGetIndex (groupfree,i,&flags);
      if(flags == 0) continue;
      printf("elem= %d\n",i);

                   /* gather element coordinates, etc. */ 
      vis_GridFunTopology (gf,i,&shape,&maxi,&maxj,&maxk);
      vis_GridFunElemNode (gf,i,&nix,ix);
      vis_GridFunCoords (gf,nix,ix,x);

                   /* gather element stress */ 
      vis_StateData (state,1,&i,(Vfloat*)s);
      vis_ConnectElemNum (connect,SYS_FACE,i,&nfaces);

                   /* set element topology */ 
      vis_ThresholdSetTopology (threshold,shape,maxi,maxj,maxk);

                   /* loop through element faces */
      for(j = 1; j <= nfaces; j++) {
         if(VIEW_FLAG(flags,j) == 0) continue;
         printf(" face= %d\n",j);

                   /* gather face normals */ 
         vis_ElemDatData (elemdat,i,j,(Vfloat*)v);

                   /* get face node indices into element connectivity */ 
         vis_GridFunElemCnn (gf,SYS_FACE,i,j,&nifx,jfx);

                   /* loop through nodes on face */ 
         for(k = 0; k < nifx; k++) {
                   /* loop through each component */ 
            for(n = 0; n < 6; n++) {
                   /* gather each component as a scalar per node */
               for(m = 0; m < nix; m++) {
                  sn[m] = s[m][n];
               }
                   /* compute gradients of normal stress field */ 
               vis_ThresholdComputeGrad (threshold,sn,x,SYS_OFF,sng);
                   /* project gradient along normal direction */ 
               nd = jfx[k]-1;
               grad = sng[nd][0]*v[k][0] +
                      sng[nd][1]*v[k][1] +
                      sng[nd][2]*v[k][2];
               printf("  node= %d, comp= %d, grad= %e\n",ix[nd],n,grad);
            }
            printf("\n");
         }
      }
   }

                   /* end objects */ 
   vis_ConnectEnd (connect);
   vis_ElemDatEnd (elemdat);
   vis_StateEnd (state);
   vis_GroupEnd (groupfree);
   vis_GridFunEnd (gf);
   vis_ThresholdEnd (threshold);
   return 0;
}

Table of Contents

25.16 Example 27, Perform Space Searches Using Space.

This example illustrates the use of a Space object to perform geometric search operations on a small finite element model consisting of two 8-node hexahedra one 4-node quadrilateral and a 2-node line. A Space object is instanced to hold a spatial decomposition for the model using the Connect object instanced for the model (see Example 23). The spatial decomposition allows for a model to be quickly searched for the elements which contain a set of points or which intersect geometric lines, planes or boxes. Before a search operation can be performed, the space kernel must be formed by calling vis_SpaceKernel. Search operations are then performed for the elements which contain a set of two points, intersect an infinite line, intersect an infinite plane and which are contained in a box. The results of each search operation are printed out.

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

                   /* example mesh is two bricks, a quad and a line */ 
#define MAX_ELEM  4
#define MAX_NODE 15

static Vint conn[MAX_ELEM][8] = {
   {1, 2, 6, 5, 9, 10, 13, 12},
   {2, 3, 7, 6, 10, 11, 14, 13},
   {3, 4, 8, 7, 0, 0, 0, 0},
   {14, 15, 0, 0, 0, 0, 0, 0} };

static Vint shap[MAX_ELEM] = {
   VIS_SHAPEHEX, VIS_SHAPEHEX, VIS_SHAPEQUAD, VIS_SHAPELINE };

static Vfloat coords[MAX_NODE][3] = {
   {0.,0.,0.}, {1.,0.,0.}, {2.,0.,0.}, {3.,0.,0.}, {0.,1.,0.},
   {1.,1.,0.}, {2.,1.,0.}, {3.,1.,0.}, {0.,0.,1.}, {1.,0.,1.},
   {2.,0.,1.}, {0.,1.,1.}, {1.,1.,1.}, {2.,1.,1.}, {3.,1.,1.} };

/*----------------------------------------------------------------------
                      Perform space searches using a Space object
----------------------------------------------------------------------*/
int
main()
{
   vis_Connect *connect;
   vis_Space   *space;
   vis_GridFun *gf;
   vis_IdTran  *idtran;
   vis_Group   *group;

   Vint i;
   Vint num_pts;
   Vfloat pts[10][3], rst[3];
   Vfloat local[10][3];
   Vfloat line_pts[2][3];
   Vint node, elem;
   Vint flag;
   Vfloat plane_pts[4][3];
   Vfloat box_pts[8][3];

                   /* create connect object */ 
   connect = vis_ConnectBegin ();
   vis_ConnectDef (connect,MAX_NODE,MAX_ELEM);

                   /* set element topologies, connectivity */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetTopology (connect,i+1,shap[i],2,0,0);
   }
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetElemNode (connect,i+1,conn[i]);
   }
                   /* set node coordinates and generate kernel */
   for(i = 0; i < MAX_NODE; i++) {
      vis_ConnectSetCoords (connect,i+1,coords[i]);
   }
   vis_ConnectKernel (connect,0);

                   /* create and load a grid function object */ 
   gf = vis_GridFunBegin ();
   vis_ConnectGridFun (connect,gf);

                   /* create space object for elements */ 
   space = vis_SpaceBegin();
   vis_SpaceSetObject (space, VIS_GRIDFUN, gf);

                   /* create kernel for entire mesh */ 
   vis_SpaceKernel (space,0);

/*----------------------------------------------------------------------
                      Search the mesh for elements which contain a set
                      of two points.  The elements which the points are 
                      in are returned in an vis_Idtran object.
----------------------------------------------------------------------*/
   printf("\n ----------  point search  ---------- \n"); 

                   /* define two points */ 
   num_pts = 2;
   pts[0][0] = 1.4; pts[0][1] = 0.6; pts[0][2] = 0.5;
   pts[1][0] = 2.3; pts[1][1] = 0.5; pts[1][2] = 0.5;

                   /* prepare idtran object for output */ 
   idtran = vis_IdTranBegin ();
   vis_IdTranDef (idtran, num_pts);

                   /* perform point search */ 
   vis_SpacePointIdTran (space,num_pts,pts,NULL,idtran,local);

                   /* print results */ 
   for(i = 1; i <= num_pts; i++) {
      vis_IdTranGetId (idtran, i, &elem);
      if (elem > 0) {
         printf("\n point %d is in element [%d].\n", i,elem); 
      } else {
         printf("\n point %d is out. \n", i); 
      }
   }
                   /* use alternative function to return natural coordinates */ 
                   /* requires ADTREE kernel to be built */
   vis_SpaceSetParami (space,SPACE_TREE,SPACE_TREE_ADTREE);
   vis_SpaceKernel (space,0);
   for(i = 1; i <= num_pts; i++) {
      vis_SpaceElemRST (space,pts[i-1],NULL,&elem,rst);
      if(elem) {
         printf("\n point %d is in element [%d], rst= %f %f %f\n",i,elem,
                 rst[0],rst[1],rst[2]);
      } else {
         printf("\n point %d is out. \n", i); 
      }
   }

/*----------------------------------------------------------------------
                      Search the mesh for the elements which intersect a
                      line.  The elements which intersect the line are 
                      returned in a vis_Group object.
----------------------------------------------------------------------*/
                   /* pick 3D elements */ 
   printf("\n ----------  line search 1 ---------- \n"); 
                   /* define line endpoints */ 
   line_pts[0][0] = -0.5; line_pts[0][1] =  0.5; line_pts[0][2] =  0.5;
   line_pts[1][0] =  0.5; line_pts[1][1] =  0.5; line_pts[1][2] =  0.5;

                   /* prepare group object for output */ 
   group = vis_GroupBegin ();
   vis_GroupDef (group, MAX_ELEM, SYS_ELEM, SYS_NONE);
   vis_GroupClear (group);

                   /* set infinite line type and perform line search */ 
   vis_SpaceSetParami (space, SPACE_LINE_INFINITE, VIS_ON);
   vis_SpaceLineGroup (space, line_pts, NULL, group);

                   /* print results */ 
   for(i = 1; i <= MAX_ELEM; i++) {
      vis_GroupGetIndex (group,i,&flag);
      if(flag) {
         printf("\n the line intersects element [%d]. \n", i); 
      } 
   }

                   /* pick 2D and 1D elements */ 
   printf("\n ----------  line search 2 ---------- \n"); 
                   /* define line endpoints */
   line_pts[0][0] =  2.5; line_pts[0][1] =  1.01; line_pts[0][2] = -0.5;
   line_pts[1][0] =  2.5; line_pts[1][1] =  1.01; line_pts[1][2] =  0.5;

   vis_GroupClear (group);

   vis_SpaceSetParamf (space, SPACE_TOLERANCE, .02);
   vis_SpaceLineGroup (space, line_pts, NULL, group);
   for(i = 1; i <= MAX_ELEM; i++) {
      vis_GroupGetIndex (group,i,&flag);
      if(flag) {
         printf("\n the line intersects element [%d]. \n", i);
      }
   }

/*----------------------------------------------------------------------
                      Search the mesh for the elements which intersect a plane.
                      The elements which intersect the plane are returned in
                      a vis_Group object.
----------------------------------------------------------------------*/
   printf("\n  ----------  plane search  ---------- \n"); 

                   /* define points in plane */ 
   plane_pts[0][0] =  0.0; plane_pts[0][1] =  0.0; plane_pts[0][2] =  0.5;
   plane_pts[1][0] =  1.5; plane_pts[1][1] =  0.0; plane_pts[1][2] =  0.5;
   plane_pts[2][0] =  1.5; plane_pts[2][1] =  2.0; plane_pts[2][2] =  0.5;
   plane_pts[3][0] =  0.0; plane_pts[3][1] =  2.0; plane_pts[3][2] =  0.5;

   vis_GroupClear (group);

                   /* perform plane search */ 
   vis_SpacePlaneGroup (space,plane_pts,NULL,group);

   for(i = 1; i <= MAX_ELEM; i++) {
      vis_GroupGetIndex (group, i, &flag);
      if(flag) {
         printf("\n  the plane intersects element [%d]. \n", i); 
      } 
   }

/*----------------------------------------------------------------------
                      search the mesh for the elements which intersect or are
                      in a box.  The elements which intersect or are in the 
                      box are returned in a vis_Group object. 
----------------------------------------------------------------------*/
   printf("\n  ----------  box search  ---------- \n"); 

                   /* set the six corners of the box. first the */
                   /* back four points, then the front. */
   box_pts[0][0] =  0.0; box_pts[0][1] =  0.1; box_pts[0][2] =  0.2;
   box_pts[1][0] =  0.4; box_pts[1][1] =  0.1; box_pts[1][2] =  0.2;
   box_pts[2][0] =  0.4; box_pts[2][1] =  0.15; box_pts[2][2] =  0.2;
   box_pts[3][0] =  0.0; box_pts[3][1] =  0.15; box_pts[3][2] =  0.2;

   box_pts[4][0] =  0.0; box_pts[4][1] =  0.1; box_pts[4][2] =  0.4;
   box_pts[5][0] =  0.4; box_pts[5][1] =  0.1; box_pts[5][2] =  0.4;
   box_pts[6][0] =  0.4; box_pts[6][1] =  0.15; box_pts[6][2] =  0.4;
   box_pts[7][0] =  0.0; box_pts[7][1] =  0.15; box_pts[7][2] =  0.4;

   vis_GroupClear (group);

                   /* perform box search */ 
   vis_SpaceBoxGroup (space, box_pts, NULL, group);

   for(i = 1; i <= MAX_ELEM; i++) {
      vis_GroupGetIndex (group, i, &flag);
      if(flag) {
         printf("\n  the element [%d] is in the box. \n", i); 
      } 
   }
/*----------------------------------------------------------------------
                      Search the mesh for the nodes which match a set
                      of input points
----------------------------------------------------------------------*/
   printf("\n ----------  point node search  ---------- \n"); 

   num_pts = 2;
   pts[0][0] = 2.0; pts[0][1] = 1.0; pts[0][2] = 0.;
   pts[1][0] = 2.5; pts[1][1] = 0.5; pts[1][2] = 0.;

                   /* create node kernel */ 
   vis_SpaceNodeKernel (space);
   vis_SpacePointNodeIdTran (space,num_pts,pts,NULL,idtran);
                   /* print results */
   for(i = 1; i <= num_pts; i++) {
      vis_IdTranGetId (idtran, i, &node);
      if (node > 0) {
         printf("\n point %d is coincident with node [%d].\n", i,node);
      } else {
         printf("\n point %d is not coincident. \n", i);
      }
   }

                   /* end objects */ 
   vis_ConnectEnd (connect);
   vis_GridFunEnd (gf);
   vis_SpaceEnd   (space);
   vis_IdTranEnd  (idtran);
   vis_GroupEnd   (group);
   return 0;
}

Table of Contents

25.17 Example 27a, Intersection and Interpolation.

This example extends the model intersection methodology illustrated in Example 27. In this case, the model is intersected by a line and the precise intersection points of the line with the element faces are computed using the vis_FaceIntersectLine function. Using this precise intersection information, the function vis_FaceInterpolate is used to interpolate a scalar field value to the intersection point. Note that the intersection testing performed by the Face module always assumes a finite length for the input line. This means that if the effect of an infinite line is required, the endpoints of the line must be adjusted to be outside of the spatial extent of the model.

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

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

                   /* example mesh is two bricks and a quad */ 
#define MAX_ELEM  3
#define MAX_NODE 14

static Vint conn[MAX_ELEM][8] = {
   {1, 2, 6, 5, 9, 10, 13, 12},
   {2, 3, 7, 6, 10, 11, 14, 13},
   {3, 4, 8, 7, 0, 0, 0, 0} };

static Vint shap[MAX_ELEM] = {
   VIS_SHAPEHEX, VIS_SHAPEHEX, VIS_SHAPEQUAD };

static Vfloat coords[MAX_NODE][3] = {
   {0.,0.,0.}, {1.,0.,0.}, {2.,0.,0.}, {3.,0.,0.}, {0.,1.,0.},
   {1.,1.,0.}, {2.,1.,0.}, {3.,1.,0.}, {0.,0.,1.}, {1.,0.,1.},
   {2.,0.,1.}, {0.,1.,1.}, {1.,1.,1.}, {2.,1.,1.} };

static Vfloat temps[MAX_NODE] = {
   0., 0., 0., 0., 0.,
   0., 0., 0., 2., 2.,
   2., 2., 2., 2. };

/*----------------------------------------------------------------------
                      Perform space searches, intersection and interpolation
----------------------------------------------------------------------*/
int
main()
{
   vis_Connect *connect;
   vis_Space   *space;
   vis_GridFun *gf;
   vis_Group   *group, *groupface;
   vis_Face    *face;
   vis_VisContext *vc;

   Vint i, j, k;
   Vint nfaces;
   Vfloat line_pts[2][3];
   Vint flag, flags;

   Vint shape, maxi, maxj;
   Vint nix, ix[8];
   Vfloat x[8][3], t[8];
   Vfloat r[2], xr[3], xd[3], tr;
   Vint status;

                   /* create connect object */ 
   connect = vis_ConnectBegin ();
   vis_ConnectDef (connect,MAX_NODE,MAX_ELEM);

                   /* set element topologies, connectivity */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetTopology (connect,i+1,shap[i],2,0,0);
   }
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetElemNode (connect,i+1,conn[i]);
   }
                   /* set node coordinates and generate kernel */
   for(i = 0; i < MAX_NODE; i++) {
      vis_ConnectSetCoords (connect,i+1,coords[i]);
   }
   vis_ConnectKernel (connect,0);

                   /* create and load a grid function object */ 
   gf = vis_GridFunBegin ();
   vis_ConnectGridFun (connect,gf);

                   /* create space object for elements */ 
   space = vis_SpaceBegin();
   vis_SpaceSetObject (space, VIS_GRIDFUN, gf);

                   /* create kernel for entire mesh */ 
   vis_SpaceKernel (space, 0);

                   /* Search the mesh for the elements which intersect line */
                   /* define line endpoints */ 
   line_pts[0][0] = -0.5; line_pts[0][1] =  0.5; line_pts[0][2] =  0.5;
   line_pts[1][0] =  2.5; line_pts[1][1] =  0.5; line_pts[1][2] =  0.5;

                   /* restrict search to elements with external faces */ 
   groupface = vis_GroupBegin ();
   vis_GroupDef (groupface,MAX_ELEM,SYS_ELEM,SYS_FACE);
   vis_ConnectFaceGroup (connect,CONNECT_FREE,NULL,groupface);

                   /* prepare group object for output */ 
   group = vis_GroupBegin ();
   vis_GroupDef (group,MAX_ELEM,SYS_ELEM,SYS_NONE);
   vis_GroupClear (group);

                   /* set infinite line type and perform line search */ 
   vis_SpaceSetParami (space, SPACE_LINE_INFINITE, VIS_ON);
   vis_SpaceLineGroup (space, line_pts, groupface, group);

   face = vis_FaceBegin ();
   vc = vis_VisContextBegin ();
   vis_FaceSetObject (face,VIS_VISCONTEXT,vc);

                   /* find precise face intersect point */
   for(i = 1; i <= MAX_ELEM; i++) {
      vis_GroupGetIndex (group,i,&flag);
      if(flag == 0) continue;
      vis_ConnectElemNum (connect,SYS_FACE,i,&nfaces);
      vis_GroupGetIndex (groupface,i,&flags);
      for(j = 1; j <= nfaces; j++) {
         if(VIEW_FLAG(flags,j) == 0) continue;
         vis_ConnectElemCon (connect,SYS_FACE,i,j,&nix,ix);
         vis_ConnectElemTopo (connect,SYS_FACE,i,j,&shape,&maxi,&maxj);
         vis_ConnectCoords (connect,nix,ix,x);
         vis_FaceSetTopology (face,shape,maxi,maxj);
         vis_FaceIntersectLine (face,x,line_pts,r,xr,xd,&status);

                   /* intersection */ 
         if(status) {
            printf("\n the line intersects element= %d, face= %d\n",i,j);
            printf("   face natural coordinates= %f,%f\n",r[0],r[1]);

                   /* gather scalar at face */ 
            for(k = 0; k < nix; k++) {
               t[k] = temps[ix[k]-1];
            }

                   /* interpolate scalar at intersection */ 
            vis_FaceInterpolate (face,r,1,t,&tr);
            printf("   scalar= %f\n",tr);
         }
      }
   }

                   /* end objects */ 
   vis_ConnectEnd (connect);
   vis_GridFunEnd (gf);
   vis_SpaceEnd   (space);
   vis_GroupEnd   (group);
   vis_GroupEnd   (groupface);
   vis_FaceEnd    (face);
   vis_VisContextEnd (vc);
   return 0;
}

Table of Contents

25.18 Example 28, Perform Range Searches Using Range.

This example illustrates the use of a Range object to perform state search operations on a small finite element model consisting of two 8-node hexahedra and one 4-node quadrilateral. A Range object is instanced to hold lists of state values for a spatial decomposition of the model using a Space object instanced for the model (see Example 27). These lists allow a model to be quickly searched for the elements which contain a specific state value. A search operation is performed for the elements which contain a given state value. The results of each search operation are printed out.

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

                   /* example mesh is two bricks and a quad */ 
#define MAX_ELEM  3
#define MAX_NODE 14

static Vint conn[MAX_ELEM][8] = {
   {1, 2, 6, 5, 9, 10, 13, 12},
   {2, 3, 7, 6, 10, 11, 14, 13},
   {3, 4, 8, 7, 0, 0, 0, 0} };

static Vint shap[MAX_ELEM] = {
   VIS_SHAPEHEX, VIS_SHAPEHEX, VIS_SHAPEQUAD };

static Vfloat coords[MAX_NODE][3] = {
   {0.,0.,0.}, {1.,0.,0.}, {2.,0.,0.}, {3.,0.,0.}, {0.,1.,0.},
   {1.,1.,0.}, {2.,1.,0.}, {3.,1.,0.}, {0.,0.,1.}, {1.,0.,1.},
   {2.,0.,1.}, {0.,1.,1.}, {1.,1.,1.}, {2.,1.,1.} };

static Vfloat scalar_1[MAX_NODE] = {
   1.0, 2.0, 3.0, 4.0, 5.0,
   6.0, 7.0, 8.0, 9.0, 10.0,
   11.0, 12.0, 13.0, 14.0 };

/*----------------------------------------------------------------------
                      Perform range searches using a Range object
----------------------------------------------------------------------*/
int
main()
{
   vis_Connect *connect;
   vis_Space *space;
   vis_GridFun *gf;
   vis_Group *group;
   vis_State *state;
   vis_Range *range;

   Vint i;
   Vint flag;
   Vint n;
   Vfloat value;

                   /* create connect object */
   connect = vis_ConnectBegin ();
   vis_ConnectDef (connect,MAX_NODE,MAX_ELEM);

                   /* set topologies */ 
   for (i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetTopology (connect,i+1,shap[i],2,0,0);
   }
                   /* set element node connectivity */ 
   for (i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetElemNode (connect,i+1,conn[i]);
   }
                   /* set node coordinates */
   for (i = 0; i < MAX_NODE; i++) {
      vis_ConnectSetCoords (connect,i+1,coords[i]);
   }
   vis_ConnectKernel (connect,0);

                   /* create and load a grid function object */
   gf = vis_GridFunBegin ();
   vis_ConnectGridFun (connect,gf);

                   /* create space object for elements */
   space = vis_SpaceBegin();
   vis_SpaceSetObject (space, VIS_GRIDFUN, gf);

                   /* create kernel for entire mesh */
   vis_SpaceKernel (space, 0);

                   /* create range object for elements */ 
   range = vis_RangeBegin();

                   /* set grid function and space objects as attributes */ 
   vis_RangeSetObject (range, VIS_GRIDFUN, gf);
   vis_RangeSetObject (range, VIS_SPACE, space);

                   /* create state object to hold data (range information) */ 
   state = vis_StateBegin ();
   vis_StateDef (state, MAX_NODE, SYS_NODE, SYS_NONE, VIS_SCALAR);

                   /* load data */ 
   for(i = 0; i < MAX_NODE; i++) {
      vis_StateSetData (state, i+1, &scalar_1[i]);
   }
 
                   /* create group object to hold output of queries */ 
   group = vis_GroupBegin ();
   vis_GroupDef (group, MAX_ELEM, SYS_ELEM, SYS_NONE);
   vis_GroupClear (group);

                   /* set state object as range 1 */ 
   vis_RangeSetState (range, 1, state);

                   /* get elements which contain a given value */
   value = 10.0;
   vis_RangeSurfGroup (range, 1, value, NULL, group);

                   /* print results */ 
   printf ("\n  ------ search elements for value [%f]  ------ \n", value);
   n = 0;
   for (i = 1; i <= MAX_ELEM; i++) {
      vis_GroupGetIndex (group, i, &flag);
      if(flag) {
         n++;
         printf ("  element [%d] contains the value. \n", i);
      }
   }
   printf ("\n  [%d] elements in group. \n\n", n);

                   /* end objects */ 
   vis_ConnectEnd (connect);
   vis_GridFunEnd (gf);
   vis_SpaceEnd   (space);
   vis_RangeEnd   (range);
   vis_StateEnd   (state);
   vis_GroupEnd   (group);
   return 0;
}

Table of Contents

25.19 Example 29, Node and Element Associations

This example illustrates the facilities within the Connect module for specifying and querying integer values associated with nodes, elements and element edges and faces. Examples of such values would be the property identifiers associated with an element, the coordinate system identifiers associated with a node, the geometry edge tag associated with an element edge. There are several types of associations which can be assigned, the complete list is documented under vis_ConnectSetElemAssoc. Each of the types of associations may be assigned to any entity, however some associations, in practice, are specifically designed for either nodes or elements. By default, each entity has a single association value of 0 for each association type (except node and element association VIS_USERID, the default value is the entity index). This default value may be changed by the user by setting the association value explicitly. In the case of element associations, the function vis_ConnectSetElemAssoc is used. Use the function vis_ConnectElemAssoc to query this single value.

Multiple values of a single association type may be assigned to a single entity. In the case of elements, use the function vis_ConnectAddElemAssoc to add associations to the single value which is set using vis_ConnectSetElemAssoc. Query all set and added associations using the function vis_ConnectAllElemAssoc. Delete all added associations using vis_ConnectDelElemAssoc. Note that the deletion only affect the additional associations added using vis_ConnectAddElemAssoc.


#include <stdio.h>
#include "base/base.h"
#include "vis/vis.h"
/*
                 5------6
                /.     /.\
  y            / .    / . \
  |           /  .   /  .  \7------8
  --x        /   1../...2../|      |
 /         12-----13-----14 |      |
z           |  .   |  .   |.|      |
            | .    | .    | 3------4
            |.     |.     |/
            9-----10-----11
*/
#define MAX_ELEM  3
#define MAX_NODE 14

static Vint conn[MAX_ELEM][8] = {
   {1, 2, 6, 5, 9,10,13,12},
   {2, 3, 7, 6,10,11,14,13},
   {3, 4, 8, 7, 0, 0, 0, 0} };

static Vint shap[MAX_ELEM] = {
   VIS_SHAPEHEX, VIS_SHAPEHEX, VIS_SHAPEQUAD };

static Vfloat coords[MAX_NODE][3] = {
   {0.,0.,0.},  {1.,0.,0.},  {2.,0.,1.},  {3.,0.,1.}, 
   {0.,1.,0.},  {1.,1.,0.},  {2.,1.,1.},  {3.,1.,1.}, 
   {0.,0.,2.},  {1.,0.,2.},  {2.,0.,2.},
   {0.,1.,2.},  {1.,1.,2.},  {2.,1.,2.} };

/*----------------------------------------------------------------------
                      Node and Element Associations
----------------------------------------------------------------------*/
int
main()
{
   vis_Connect *connect;
   Vint i;
   Vint id, aid, num, aids[3];

                   /* create connect object */
   connect = vis_ConnectBegin ();
   vis_ConnectDef (connect,MAX_NODE,MAX_ELEM);

                   /* set topologies */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetTopology (connect,i+1,shap[i],2,0,0);
   }
                   /* set element node connectivity */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetElemNode (connect,i+1,conn[i]);
   }
                   /* set node coordinates */ 
   for(i = 0; i < MAX_NODE; i++) {
      vis_ConnectSetCoords (connect,i+1,coords[i]);
   }
                   /* set node association */ 
   vis_ConnectSetNodeAssoc (connect,VIS_CSYSID,5,100);
                   /* query node association */ 
   id = 5;
   vis_ConnectNodeAssoc (connect,VIS_CSYSID,1,&id,&aid);
   printf("node 5, aid= %d\n",aid);

                   /* add another node association of same type to same node */ 
   vis_ConnectAddNodeAssoc (connect,VIS_CSYSID,id,101);
   vis_ConnectNumNodeAssoc (connect,VIS_CSYSID,id,&num);
   printf("node 5, num= %d\n",num);
   vis_ConnectAllNodeAssoc (connect,VIS_CSYSID,id,&num,aids);
   for(i = 0; i < num; i++) {
      printf("node 5, aid[%d]= %d\n",i,aids[i]);
   }
                   /* now delete added associations */ 
   vis_ConnectDelNodeAssoc (connect,VIS_CSYSID,id);
   vis_ConnectNumNodeAssoc (connect,VIS_CSYSID,id,&num);
   printf("node 5, num= %d\n",num);
   vis_ConnectAllNodeAssoc (connect,VIS_CSYSID,id,&num,aids);
   for(i = 0; i < num; i++) {
      printf("node 5, aid[%d]= %d\n",i,aids[i]);
   }
                   /* now set element face entity associations */ 
   vis_ConnectSetElemEntAssoc (connect,VIS_GEOFACE,SYS_FACE,2,1,100);
   vis_ConnectSetElemEntAssoc (connect,VIS_GEOFACE,SYS_FACE,3,1,100);

                   /* set element edge entity association */ 
                   /* element 3, edge 2 */
   vis_ConnectSetElemEntAssoc (connect,VIS_GEOEDGE,SYS_EDGE,3,2,1);

                   /* query element edge association */ 
                   /* undefined associations return 0 */ 
   vis_ConnectElemEntAssoc (connect,VIS_GEOEDGE,SYS_EDGE,3,1,&aid);
   printf("element 3, edge 1, aid= %d\n",aid);
                   /* element 3, edge 2 */
   vis_ConnectElemEntAssoc (connect,VIS_GEOEDGE,SYS_EDGE,3,2,&aid);
   printf("element 3, edge 2, aid= %d\n",aid);

                   /* additional associations */
   printf("\nTest adding non-unique associations\n");
   vis_ConnectAddElemEntAssoc (connect,VIS_GEOFACE,SYS_FACE,2,1,100);
   vis_ConnectAllElemEntAssoc (connect,VIS_GEOFACE,SYS_FACE,2,1,&num,aids);
   printf("element 2, face 1, num= %d\n",num);
   for(i = 0; i < num; i++) {
      printf("element 2, face 1, aid[%d]= %d\n",i,aids[i]);
   }
                   /* delete all associations */
   printf("\nTest delete additional associations\n");
   vis_ConnectDelElemEntAssoc (connect,VIS_GEOFACE,SYS_FACE,2,1);
   vis_ConnectAllElemEntAssoc (connect,VIS_GEOFACE,SYS_FACE,2,1,&num,aids);
   printf("element 2, face 1, num= %d\n",num);
   for(i = 0; i < num; i++) {
      printf("element 2, face 1, aid[%d]= %d\n",i,aids[i]);
   }
                   /* add associations to elements with no set association */
   printf("\nTest adding associations without set association\n");
   vis_ConnectAddElemEntAssoc (connect,VIS_GEOFACE,SYS_FACE,6,5,50);
   vis_ConnectAllElemEntAssoc (connect,VIS_GEOFACE,SYS_FACE,6,5,&num,aids);
   printf("element 6, face 5, num= %d\n",num);
   for(i = 0; i < num; i++) {
      printf("element 6, face 5, aid[%d]= %d\n",i,aids[i]);
   }
                   /* end objects */ 
   vis_ConnectEnd (connect);
   return 0;
}

Table of Contents

25.20 Example 30, Demo Visualizer Progressive Example

This example illustrates the use of both global and local VisTools objects to construct a simple finite element visualizer.

This example is extended using VglTools objects in files exam30avgl.c, exam30bvgl.c and exam30cvgl.c.

#include "base/base.h"
#include "vgl/vgl.h"
#include "vis/vis.h"

#include "glwin.h"

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

void
draw_ElemEdge(vis_Group *group, vis_Connect *connect,
              vis_State *stated, vis_Edge *edge);
void
draw_ElemFaceGroup(vis_Group *group, vis_Connect *connect,
                   vis_State *stated, vis_Face *face);
void
draw_ElemFaceIdTran(vis_IdTran *idtran, vis_Connect *connect,
                    vis_State *stated, vis_Face *face);
void
draw_ElemFaceContour(vis_Group *group, vis_Connect *connect,
                    vis_State *state, vis_State *stated, vis_Contour *contour);
void
draw_ElemIsosurface(vis_Group *group, vis_Connect *connect,
                vis_State *state, vis_State *stated, vis_Threshold *threshold);
void
draw_NodeMark(vis_Group *group, vis_Connect *connect,
           Vint datatype, vis_State *state, vis_State *stated, vis_Mark *mark);

                   /* Red,Green,Blue components of entity Colormap */
static Vfloat rgb[8][3] = {
   {.5,.5,.5}, {1.,0.,0.}, {0.,1.,0.}, {0.,0.,1.},
   {0.,1.,1.}, {1.,0.,1.}, {1.,1.,0.}, {1.,1.,1.} };

/*----------------------------------------------------------------------
                      Demo visualizer
----------------------------------------------------------------------*/
int
main()
{
   vis_Connect    *connect;
   vis_GridFun    *gf;
   vis_Group      *groupedge, *groupface;
   vis_IdTran     *idtranface;
   vis_State      *state;

   vis_VisContext *vc;
   vis_Levels     *levels;
   vis_ColorMap   *cmap, *cmapiso;
   vis_Edge       *edge;
   vis_Face       *face;
   vis_Mark       *mark;
   vis_Contour    *contour;
   vis_Threshold  *threshold;
   GLWin          *glwin;
   vgl_DrawFun    *df;

   int i, j;
   Vint nlevels;
   Vfloat sminmax[2];
   Vint numnp, numel;
   Vfloat xtext[3], ctext[3];

                   /* create GL device */
   glwin = GLWinBegin ();
   GLWinCreateWindow (glwin,200,200,400,400);
   GLWinOrtho (glwin,-3.,3.,-3.,3.,-300.,300.);

                   /* create draw function object for GL */
   df = vgl_DrawFunBegin ();
   GLWinDrawFun (glwin,df);

                   /* create demo cylindrical brick 1000 element model */ 
   connect = vis_ConnectBegin ();
   vis_ConnectDemo (connect,CONNECT_DEMO_CYLINDER,1.,VIS_SHAPEHEX,11,11,11);
   vis_ConnectNumber (connect,SYS_NODE,&numnp);
   vis_ConnectNumber (connect,SYS_ELEM,&numel);

                   /* generate connect kernel */
   vis_ConnectKernel (connect,0);

                   /* create a grid function object */
   gf = vis_GridFunBegin ();
   vis_ConnectGridFun (connect,gf);

                   /* instance state object to hold demo node vector result */
   state = vis_StateBegin ();
   vis_StateDef (state,numnp,SYS_NODE,SYS_NONE,SYS_VECTOR);
   vis_StateSetObject (state,VIS_GRIDFUN,gf);
   vis_StateDemo (state,STATE_DEMO_PLATE,.25,NULL);

                   /* compute results minmax */
   vis_StateSetDerive (state,VIS_VECTOR_MAG);
   vis_StateExtent (state,NULL,sminmax);

                   /* build free face group */
   groupface = vis_GroupBegin ();
   vis_GroupDef (groupface,numel,SYS_ELEM,SYS_FACE);
   vis_ConnectFaceGroup (connect,CONNECT_FREE,NULL,groupface);
   idtranface = vis_IdTranBegin ();
   vis_IdTranGroup (idtranface,groupface);

                   /* build free face feature edge group */
   groupedge = vis_GroupBegin ();
   vis_GroupDef (groupedge,numel,SYS_ELEM,SYS_EDGE);
   vis_ConnectEdgeGroup (connect,CONNECT_FEATURE,groupface,groupedge);

                   /* vis context and set attributes */
   vc = vis_VisContextBegin ();

                   /* levels, set evenly spaced levels */
   levels = vis_LevelsBegin ();
   nlevels = 10;
   vis_LevelsDef (levels,LEVELS_LINEAR,nlevels);
   vis_LevelsSetMinMax (levels,sminmax[0],sminmax[1]);
   vis_LevelsGenerate (levels,LEVELS_PADTOP);

                   /* color map for isovalues */
   cmapiso = vis_ColorMapBegin ();
   vis_ColorMapRamp (cmapiso,nlevels,1,COLORMAP_HUE);

                   /* color map for entities */
   cmap = vis_ColorMapBegin ();
   vis_ColorMapSetRGB (cmap,8,0,rgb);

                   /* create mark object and set objects */
   mark = vis_MarkBegin ();
   vis_MarkSetObject (mark,VGL_DRAWFUN,df);
   vis_MarkSetObject (mark,VIS_VISCONTEXT,vc);
   vis_MarkSetObject (mark,VIS_LEVELS,levels);
   vis_MarkSetObject (mark,VIS_COLORMAP,cmapiso);

                   /* create contour object and set objects */
   contour = vis_ContourBegin ();
   vis_ContourSetObject (contour,VGL_DRAWFUN,df);
   vis_ContourSetObject (contour,VIS_VISCONTEXT,vc);
   vis_ContourSetObject (contour,VIS_LEVELS,levels);
   vis_ContourSetObject (contour,VIS_COLORMAP,cmapiso);

                   /* create threshold object and set objects */
   threshold = vis_ThresholdBegin ();
   vis_ThresholdSetObject (threshold,VGL_DRAWFUN,df);
   vis_ThresholdSetObject (threshold,VIS_VISCONTEXT,vc);
   vis_ThresholdSetObject (threshold,VIS_LEVELS,levels);
   vis_ThresholdSetObject (threshold,VIS_COLORMAP,cmapiso);

                   /* create edge object and set objects */
   edge = vis_EdgeBegin ();
   vis_EdgeSetObject (edge,VGL_DRAWFUN,df);
   vis_EdgeSetObject (edge,VIS_VISCONTEXT,vc);
   vis_EdgeSetObject (edge,VIS_COLORMAP,cmap);

                   /* create face object and set objects */
   face = vis_FaceBegin ();
   vis_FaceSetObject (face,VGL_DRAWFUN,df);
   vis_FaceSetObject (face,VIS_VISCONTEXT,vc);
   vis_FaceSetObject (face,VIS_COLORMAP,cmap);

   xtext[0] = -2.5;
   xtext[1] = 2.5;
   xtext[2] = 0.;
   ctext[0] = 1.;
   ctext[1] = 1.;
   ctext[2] = 1.;
                   /* loop through visualization types */ 
   for(j = 0; j < 5; j++) {
      for(i = 0; i < 8; i++) {
         GLWinClear (glwin);
         GLWinColor (glwin,ctext);
         if(j == 0) {
            GLWinText (glwin,xtext,"draw_ElemFaceGroup");
         } else if(j == 1) {
            GLWinText (glwin,xtext,"draw_ElemFaceIdTran");
         } else if(j == 2) {
            GLWinText (glwin,xtext,"draw_ElemFaceContour");
         } else if(j == 3) {
            GLWinText (glwin,xtext,"draw_ElemIsosurface");
         } else if(j == 4) {
            GLWinText (glwin,xtext,"draw_NodeMark");
         }
         GLWinXfmPush (glwin);
         GLWinRotate (glwin,i*4.,'X');
         GLWinRotate (glwin,-i*4.,'Y');
         vis_VisContextSetColor (vc,7);
         draw_ElemEdge (groupedge,connect,NULL,edge);
                   /* draw elem face subset using a Group object */ 
         if(j == 0) {
            vis_VisContextSetColor (vc,0);
            draw_ElemFaceGroup (groupface,connect,NULL,face);
                   /* draw elem face subset using an IdTran object */ 
         } else if(j == 1) {
            vis_VisContextSetColor (vc,0);
            draw_ElemFaceIdTran (idtranface,connect,NULL,face);
                   /* draw elem face contours */
         } else if(j == 2) {
            vis_StateSetDerive (state,VIS_VECTOR_MAG);
            vis_VisContextSetIsoValType (vc,VIS_ISOVALFRINGE);
            draw_ElemFaceContour (groupface,connect,state,NULL,contour);
                   /* draw elem isosurfaces */
         } else if(j == 3) {
            vis_StateSetDerive (state,VIS_VECTOR_MAG);
            vis_VisContextSetIsoValType (vc,VIS_ISOVALSURFACE);
            draw_ElemIsosurface (NULL,connect,state,NULL,threshold);
                   /* draw node vector markers */
         } else if(j == 4) {
            vis_StateSetDerive (state,VIS_VECTOR);
            vis_VisContextSetVectorType (vc,VIS_VECTORUMBRELLA);
            vis_VisContextSetComponent (vc,VIS_COMPONENT_PRINCIPAL);
            vis_VisContextSetSize (vc,.25);
            vis_VisContextSetFlags (vc,VIS_VECTORTAIL | VIS_VECTORTAILREGISTER);
            draw_NodeMark (NULL,connect,VIS_VECTOR,state,NULL,mark);
         }
         GLWinXfmPop (glwin);
         GLWinSwap (glwin);
         sleep(1);
      }
   }
   sleep(5);

                   /* free all objects */ 
   vis_ConnectEnd    (connect);
   vis_StateEnd      (state);
   vis_GroupEnd      (groupface);
   vis_GroupEnd      (groupedge);
   vis_GridFunEnd    (gf);
   vgl_DrawFunEnd    (df);
   vis_VisContextEnd (vc);
   vis_LevelsEnd     (levels);
   vis_ColorMapEnd   (cmapiso);
   vis_ColorMapEnd   (cmap);
   vis_MarkEnd       (mark);
   vis_ContourEnd    (contour);
   vis_ThresholdEnd  (threshold);
   vis_EdgeEnd       (edge);
   vis_FaceEnd       (face);
   GLWinEnd          (glwin);
   return 0;
}

/*----------------------------------------------------------------------
                      Draw Element Edges
----------------------------------------------------------------------*/
void
draw_ElemEdge(vis_Group *group, vis_Connect *connect,
              vis_State *stated, vis_Edge *edge)
{
   Vint numel;
   Vint n, j;
   Vint flags;
   Vint nedges;
   Vint shape, maxi, maxj;
   Vint nix;
   Vint ix[8];
   Vfloat x[8][3];

                   /* get number of elements */
   vis_ConnectNumber (connect,SYS_ELEM,&numel);

                   /* draw element edges */
                   /* loop through elements */
   for(n = 1; n <= numel; n++) {
      vis_GroupGetIndex (group,n,&flags);
      if(flags == 0) continue;
      vis_ConnectElemNum (connect,SYS_EDGE,n,&nedges);

                   /* loop through element edges */
      for(j = 1; j <= nedges; j++) {
         if(VIEW_FLAG(flags,j) == 0) continue;
         vis_ConnectElemCon (connect,SYS_EDGE,n,j,&nix,ix);
         vis_ConnectElemTopo (connect,SYS_EDGE,n,j, &shape, &maxi, &maxj);
         if(stated != NULL) {
            vis_StateData (stated,nix,ix,(Vfloat*)x);
         } else {
            vis_ConnectCoords (connect,nix,ix,x);
         }
         vis_EdgeSetTopology (edge,SYS_SHAPELINE,nix);
         vis_EdgeCurv (edge,x);
      }
   }
}

/*----------------------------------------------------------------------
                      Draw Element Face using Group
----------------------------------------------------------------------*/
void
draw_ElemFaceGroup(vis_Group *group, vis_Connect *connect,
                   vis_State *stated, vis_Face *face)
{
   Vint numel;
   Vint n, j;
   Vint flags;
   Vint nfaces;
   Vint shape, maxi, maxj;
   Vint nix;
   Vint ix[VIS_MAXFACENODE];
   Vfloat x[VIS_MAXFACENODE][3];

                   /* get number of elements */
   vis_ConnectNumber (connect,SYS_ELEM,&numel);
                   /* draw element faces */
                   /* loop through elements */
   for(n = 1; n <= numel; n++) {
      vis_GroupGetIndex (group,n,&flags);
      if(flags == 0) continue;
      vis_ConnectElemNum (connect,SYS_FACE,n,&nfaces);
                   /* loop through element faces */
      for(j = 1; j <= nfaces; j++) {
         if(VIEW_FLAG(flags,j) == 0) continue;
         vis_ConnectElemCon (connect,SYS_FACE,n,j,&nix,ix);
         vis_ConnectElemTopo (connect,SYS_FACE,n,j, &shape, &maxi, &maxj);
         if(stated != NULL) {
            vis_StateData (stated,nix,ix,(Vfloat*)x);
         } else {
            vis_ConnectCoords (connect,nix,ix,x);
         }
         vis_FaceSetTopology (face,shape,maxi,maxj);
         vis_FaceCurv (face,x,VIS_NODATA,NULL);
      }
   }
}

/*----------------------------------------------------------------------
                      Draw Element Face using IdTran
----------------------------------------------------------------------*/
void
draw_ElemFaceIdTran(vis_IdTran *idtran, vis_Connect *connect,
                    vis_State *stated, vis_Face *face)
{
   Vint maxind;
   Vint i, n, j;
   Vint shape, maxi, maxj;
   Vint nix;
   Vint ix[VIS_MAXFACENODE];
   Vfloat x[VIS_MAXFACENODE][3];

                   /* get number of indices with faces */
   vis_IdTranCount (idtran,IDTRAN_MAXINDEX,&maxind);
                   /* draw element faces */
                   /* loop through indices */
   for(i = 1; i <= maxind; i++) {
      vis_IdTranGetId (idtran,i,&n);
      if(n == 0)  continue;
                   /* get element face */
      vis_IdTranGetEnt (idtran,i,&j);
      vis_ConnectElemCon (connect,SYS_FACE,n,j,&nix,ix);
      vis_ConnectElemTopo (connect,SYS_FACE,n,j,&shape,&maxi,&maxj);
      if(stated != NULL) {
         vis_StateData (stated,nix,ix,(Vfloat*)x);
      } else {
         vis_ConnectCoords (connect,nix,ix,x);
      }
      vis_FaceSetTopology (face,shape,maxi,maxj);
      vis_FaceCurv (face,x,VIS_NODATA,NULL);
   }
}
  
/*----------------------------------------------------------------------
                      Draw Element Face Contours
----------------------------------------------------------------------*/
void
draw_ElemFaceContour(vis_Group *group, vis_Connect *connect,
                    vis_State *state, vis_State *stated, vis_Contour *contour)
{
   Vint numel;
   Vint n, j;
   Vint flags;
   Vint nfaces;
   Vint shape, maxi, maxj;
   Vint nix;
   Vint ix[8];
   Vfloat x[8][3];
   Vfloat s[8];

                   /* get number of elements */
   vis_ConnectNumber (connect,SYS_ELEM,&numel);
                   /* contour on element faces */
                   /* loop through elements */
   for(n = 1; n <= numel; n++) {
      vis_GroupGetIndex (group,n,&flags);
      if(flags == 0) continue;
      vis_ConnectElemNum (connect,SYS_FACE,n,&nfaces);
                   /* loop through element faces */
      for(j = 1; j <= nfaces; j++) {
         if(VIEW_FLAG(flags,j) == 0) continue;
         vis_ConnectElemCon (connect,SYS_FACE,n,j,&nix,ix);
         vis_ConnectElemTopo (connect,SYS_FACE,n,j, &shape, &maxi, &maxj);
         if(stated != NULL) {
            vis_StateData (stated,nix,ix,(Vfloat*)x);
         } else {
            vis_ConnectCoords (connect,nix,ix,x);
         }
         vis_StateData (state,nix,ix,s);
         vis_ContourSetTopology (contour,shape,maxi,maxj);
         vis_ContourCurv (contour,s,x,VIS_NODATA,NULL);
      }
   }
}

/*----------------------------------------------------------------------
                      Draw Element Isosurfaces
----------------------------------------------------------------------*/
void
draw_ElemIsosurface(vis_Group *group, vis_Connect *connect,
                vis_State *state, vis_State *stated, vis_Threshold *threshold)
{
   Vint numel;
   Vint n;
   Vint shape, maxi, maxj, maxk;
   Vint nix;
   Vint flags;
   Vint ix[VIS_MAXCELLNODE];
   Vfloat x[VIS_MAXCELLNODE][3];
   Vfloat s[VIS_MAXCELLNODE];

                   /* get number of elements */
   vis_ConnectNumber (connect,SYS_ELEM,&numel);
                   /* loop through all elements */
   for(n = 1; n <= numel; n++) {
      if(group != NULL) {
         vis_GroupGetIndex (group,n,&flags);
         if(flags == 0) continue;
      }
      vis_ConnectTopology (connect,n,&shape,&maxi,&maxj,&maxk);
      if(shape == SYS_SHAPETET  ||
         shape == SYS_SHAPEPYR  ||
         shape == SYS_SHAPEWED  ||
         shape == SYS_SHAPEHEX) {
                /* draw isosurfaces */
         vis_ConnectElemNode (connect,n,&nix,ix);
         if(stated != NULL) {
            vis_StateData (stated,nix,ix,(Vfloat*)x);
         } else {
            vis_ConnectCoords (connect,nix,ix,x);
         }
         vis_StateData (state,nix,ix,s);
         vis_ThresholdSetTopology (threshold,shape,maxi,maxj,maxk);
         vis_ThresholdCurv (threshold,s,x,VIS_NODATA,NULL);
      }
   }
}

/*----------------------------------------------------------------------
                      Draw Node Markers
----------------------------------------------------------------------*/
void
draw_NodeMark(vis_Group *group, vis_Connect *connect,
           Vint datatype, vis_State *state, vis_State *stated, vis_Mark *mark)
{
   Vint numnp;
   Vint n;
   Vint flags;
   Vfloat x[3];
   Vfloat s[6];

                   /* get number of nodes */
   vis_ConnectNumber (connect,SYS_NODE,&numnp);
                   /* markers at nodes */
                   /* loop through nodes */
   for(n = 1; n <= numnp; n++) {
      if(group != NULL) {
         vis_GroupGetIndex (group,n,&flags);
         if(flags == 0) continue;
      }
      if(stated != NULL) {
         vis_StateData (stated,1,&n,x);
      } else {
         vis_ConnectCoords (connect,1,&n,(Vfloat(*)[3])x);
      }
      vis_StateData (state,1,&n,s);
      if(datatype == VIS_SCALAR) {
         vis_MarkScalar (mark,1,s,(Vfloat(*)[3])x);
      } else if(datatype == VIS_VECTOR) {
         vis_MarkVector (mark,1,(Vfloat(*)[3])s,(Vfloat(*)[3])x);
      } else if(datatype == VIS_TENSOR) {
         vis_MarkTensor (mark,1,(Vfloat(*)[6])s,(Vfloat(*)[3])x);
      }
   }
}

Table of Contents

25.21 Example 31, Perform Element Checking Using ElemChk.

This example illustrates the use of an ElemChk object to perform a number of element checks including calculation of shape distortion parameters, consistency of normals and size growth rate. In this example three quadrilateral elements and eight nodes are defined. Each element size and shape is varied to illustrate the shape parameters which are computed. The sense of the connectivity of the third element has been reversed so that the consistent normal or handedness check will detect it. A ElemChk object requires access to finite element model information via a GridFun object. A Connect object is instanced to hold the finite element model and a GridFun object is prepared. An ElemChk object is instanced and the GridFun object is registered with it.

The first element check is the computation of a set of shape parameters using vis_ElemChkData. A State object is instanced to hold the element area in preparation for the area growth rate calculation to occur later. The function vis_ElemChkSetType is called to specify the types of shape parameters to be calculated. Next, element normals are computed using vis_ElemChkNorm. It can be seen that the normal of element 3 is reversed and the edge flags for both element 2 and 3 flag the edge adjacent to the element with the inconsistent connectivity sense. Lastly, the growth rate of the element size of computed for all elements using vis_ElemChkRate. The results of each element check are printed out.

#include <stdio.h>
#include "base/base.h"
#include "vis/vis.h"
/*
                8
              . .
             .  .
           7    6
           .  . .
  y        . .  .
  |        5    .
  --x      .    .
           3....4
           .    .
           .    .
           1....2
*/
#define MAX_ELEM  3
#define MAX_NODE  8

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

static Vfloat coords[MAX_NODE][3] = {
   {0.,0.,0.},  {2.,0.,0.},
   {0.,2.,0.},  {2.,2.,0.},
   {0.,3.,0.},  {2.,4.,0.},
   {0.,4.,0.},  {2.,5.,0.} };

/*----------------------------------------------------------------------
                      Element Checking
----------------------------------------------------------------------*/
int
main()
{
   Vint i;
   vis_Connect *connect;
   vis_ElemChk *elemchk;
   vis_State *state;
   vis_GridFun *gf;
   Vfloat s[ELEMCHK_MAX];
   Vfloat vn[3];
   Vint edgeflags;

                   /* create connect object */
   connect = vis_ConnectBegin ();
   vis_ConnectDef (connect,MAX_NODE,MAX_ELEM);

                   /* set topologies and element connectivity */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetTopology (connect,i+1,SYS_SHAPEQUAD,2,0,0);
      vis_ConnectSetElemNode (connect,i+1,conn[i]);
   }
                   /* set node coordinates */ 
   for(i = 0; i < MAX_NODE; i++) {
      vis_ConnectSetCoords (connect,i+1,coords[i]);
   }
                   /* generate connect kernel */
   vis_ConnectKernel (connect,0);

                   /* create a grid function object */
   gf = vis_GridFunBegin ();
   vis_ConnectGridFun (connect,gf);

                   /* create a ElemChk object */ 
   elemchk = vis_ElemChkBegin ();

                   /* install GridFun object */ 
   vis_ElemChkSetObject (elemchk,VIS_GRIDFUN,gf);

                   /* instance a state object to hold areas */ 
   state = vis_StateBegin ();
   vis_StateDef (state,MAX_ELEM,SYS_ELEM,SYS_NONE,SYS_SCALAR);

                   /* set area, taper, skew and aspect ratio */ 
   vis_ElemChkSetType (elemchk,ELEMCHK_JACOBIAN_SUM,SYS_ON);
   vis_ElemChkSetType (elemchk,ELEMCHK_FACE_TAPER,SYS_ON);
   vis_ElemChkSetType (elemchk,ELEMCHK_SKEW,SYS_ON);
   vis_ElemChkSetType (elemchk,ELEMCHK_ASPECT_RATIO,SYS_ON);
   vis_ElemChkSetType (elemchk,ELEMCHK_EDGEALT_RATIO,SYS_ON);
   vis_ElemChkSetType (elemchk,ELEMCHK_CG_X,SYS_ON);
   vis_ElemChkSetType (elemchk,ELEMCHK_MIN_ANGLE,SYS_ON);
   vis_ElemChkSetType (elemchk,ELEMCHK_MAX_ANGLE,SYS_ON);
   vis_ElemChkSetType (elemchk,ELEMCHK_HANDEDNESS,SYS_ON);

                   /* compute shape parameters */ 
   printf("Shape Parameters\n");
   for(i = 1; i <= MAX_ELEM; i++) {
      vis_ElemChkData (elemchk,i,s);
      printf("element= %d\n",i);
      printf(" area          = %e\n",s[ELEMCHK_JACOBIAN_SUM]);
      printf(" taper         = %e\n",s[ELEMCHK_FACE_TAPER]);
      printf(" skew          = %e\n",s[ELEMCHK_SKEW]);
      printf(" aspect ratio  = %e\n",s[ELEMCHK_ASPECT_RATIO]);
      printf(" edgealt ratio = %e\n",s[ELEMCHK_EDGEALT_RATIO]);
      printf(" cg            = %e %e %e\n",s[ELEMCHK_CG_X],
                                           s[ELEMCHK_CG_Y],
                                           s[ELEMCHK_CG_Z]);
      printf(" min angle     = %e\n",s[ELEMCHK_MIN_ANGLE]);
      printf(" max angle     = %e\n",s[ELEMCHK_MAX_ANGLE]);
      printf(" handedness    = %e\n",s[ELEMCHK_HANDEDNESS]);
      vis_StateSetData (state,i,&s[ELEMCHK_JACOBIAN_SUM]);
   }
                   /* check normals */ 
   printf("Check Normals\n");
   for(i = 1; i <= MAX_ELEM; i++) {
      vis_ElemChkNorm (elemchk,NULL,i,vn,&edgeflags);
      printf("element= %d\n",i);
      printf(" normal    = %f,%f,%f\n",vn[0],vn[1],vn[2]);
      printf(" edgeflags = %d\n",edgeflags);
   }
                   /* growth rate */ 
   printf("Growth Rate\n");
   for(i = 1; i <= MAX_ELEM; i++) {
      vis_ElemChkRate (elemchk,state,NULL,i,s);
      printf("element= %d\n",i);
      printf(" maximum rate   = %e\n",s[0]);
      printf(" maximum change = %e\n",s[1]);
   }

                   /* end objects */ 
   vis_ConnectEnd (connect);
   vis_GridFunEnd (gf);
   vis_ElemChkEnd (elemchk);
   vis_StateEnd (state);
   return 0;
}

Table of Contents

25.22 Example 31a, Compute Model Mass Properties Using MassPrp

This example illustrates the use of a MassPrp object to compute mass properties of a model. The model consists of 2 solid elements. The density is 1.e-5. The minimum requirements of the model are the node coordinates, element connectivity, type and element property identifier or material identifier and associated element property objects, EProp and/or material property objects, MProp. If an element property identifier is specified, VIS_PROPID, then a HashTable of EProp objects must be generated which contain an EProp object for each unique element property identifier. These EProp objects must in turn contain a material property identifier. Alternatively, a material identifier may be specified, VIS_MATLID, which references an MProp object directly without the need for an intermediate EProp object. A HashTable of MProp objects must be specified and contain a MProp object for each unique material property identifier. An MassPrp object is instanced and the Model object is registered with it.

The mass properties are computed using vis_MassPrpCompute. The total mass, center of mass and inertia tensor about the center of mass are computed and printed. The function vis_MassPrpPrincipal is used to compute the principal values and directions of the inertia tensor.

#include "base/base.h"
#include "vis/vis.h"
/*
                 4------5------6
                /.     /.     /.
               / .    / .    / .
              /  .   /  .   /  .
             /   1../...2../...3
            10-----11-----12  /
            |  .   |  .   |  /
            | .    | .    | /
            |.     |.     |/
            7------8------9

         y
         |
         --- x
       /
      z
*/
#define MAX_ELEM  2
#define MAX_NODE 12

                   /* element connectivity */ 
static Vint conn[MAX_ELEM][8] = {
   {1, 2, 5, 4, 7, 8,11,10},
   {2, 3, 6, 5, 8, 9,12,11} };

                   /* element topologies */ 
static Vint shap[MAX_ELEM] = {
   VIS_SHAPEHEX, VIS_SHAPEHEX };
static Vint maxi[MAX_ELEM] = {
   2, 2 };
                   /* element types */ 
static Vint featype[MAX_ELEM] = {
   VIS_ELEM_SOLID, VIS_ELEM_SOLID };

                   /* element property ids */ 
static Vint pid[MAX_ELEM] = {
   1, 1 };
                   /* node coordinates */ 
static Vdouble coords[MAX_NODE][3] = {
   {0.,0.,0.},  {1.,0.,0.},  {2.,0.,0.},
   {0.,1.,0.},  {1.,1.,0.},  {2.,1.,0.},
   {0.,0.,3.},  {1.,0.,3.},  {2.,0.,3.},
   {0.,1.,3.},  {1.,1.,3.},  {2.,1.,3.} };

/*----------------------------------------------------------------------
                      Model Mass Properties Using MassPrp
----------------------------------------------------------------------*/
int
main()
{
   Vint i;
   vis_Model *model;
   vis_Connect *connect;
   vis_MassPrp *massprp;
   vis_MProp *mprop;
   vis_EProp *eprop;
   vsy_HashTable *ephash, *mphash;
   Vfloat vtot, mtot, xcom[3], mten[6];
   Vfloat mpri[3], tm[3][3];

                   /* create connect object */
   connect = vis_ConnectBegin ();
   vis_ConnectPre (connect,SYS_DOUBLE);
   vis_ConnectDef (connect,MAX_NODE,MAX_ELEM);

                   /* set node coordinates and user ids */ 
   for(i = 0; i < MAX_NODE; i++) {
      vis_ConnectSetCoordsdv (connect,i+1,coords[i]);
   }
                   /* set element topologies */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetTopology (connect,i+1,shap[i],maxi[i],0,0);
   }
                   /* set element node connectivity and associations */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetElemNode (connect,i+1,conn[i]);
      vis_ConnectSetElemAssoc (connect,VIS_FEATYPE,i+1,featype[i]);
      vis_ConnectSetElemAssoc (connect,VIS_PROPID,i+1,pid[i]);
   }

                   /* create model object hierarchy */ 
   model = vis_ModelBegin ();

                   /* hashtables of properties */
   mphash = vsy_HashTableBegin ();
   ephash = vsy_HashTableBegin ();

                   /* material 1 */ 
   mprop = vis_MPropBegin ();
   vis_MPropDef (mprop,SYS_MAT_ISOTROPIC);
   vis_MPropSetValued (mprop,MPROP_E,1.e+7);
   vis_MPropSetValued (mprop,MPROP_NU,.3);
   vis_MPropSetValued (mprop,MPROP_DENSITY,1.e-05);
   vsy_HashTableInsert (mphash,1,mprop);

                   /* solid property 1 */
   eprop = vis_EPropBegin ();
   vis_EPropDef (eprop,VIS_ELEM_SOLID);
   vis_EPropSetValuei (eprop,EPROP_MID,1);
   vsy_HashTableInsert (ephash,1,eprop);

                   /* register Connect in Model */ 
   vis_ModelSetObject (model,VIS_CONNECT,connect);

                   /* register property hashtables in Model */ 
   vis_ModelSetHashTable (model,VIS_MPROP,mphash);
   vis_ModelSetHashTable (model,VIS_EPROP,ephash);

                   /* compute and print mass properties */ 
   massprp = vis_MassPrpBegin();
   vis_MassPrpSetObject (massprp,VIS_MODEL,model);
   vis_MassPrpCompute (massprp,NULL,&vtot,&mtot,xcom,mten);

   printf("Total volume   = %e\n",vtot);
   printf("Total mass     = %e\n",mtot);
   printf("Center of mass = %e %e %e\n",xcom[0],xcom[1],xcom[2]);
   printf("Inertia tensor = %e %e %e\n",mten[0],mten[1],mten[2]);
   printf("                 %e %e %e\n",mten[3],mten[4],mten[5]);

                   /* compute principal values and directions */
   vis_MassPrpPrincipal (massprp,mten,mpri,tm);
   printf("Principal values = %e %e %e\n",mpri[0],mpri[1],mpri[2]);
   printf("Principal directions = %e %e %e\n",tm[0][0],tm[0][1],tm[0][2]);
   printf("                     = %e %e %e\n",tm[1][0],tm[1][1],tm[1][2]);
   printf("                     = %e %e %e\n",tm[2][0],tm[2][1],tm[2][2]);

                   /* delete objects */ 
   vis_MassPrpEnd (massprp);
                   /* Use convenience routine ModelDelete to destroy
                      all objects registered in Model */
   vis_ModelDelete (model);
                   /* finally destroy Model object */ 
   vis_ModelEnd (model);
   return 0;
}

Table of Contents

25.23 Example 32, Manage Loads Using LCase

This example illustrates the use of a LCase object to manage concentrated nodal loads, distributed element loads and overall model accelerations on a small finite element model consisting of two 8-node hexahedra and one 4-node quadrilateral. The model is loaded into a Connect object. A GridFun object is instanced and loaded with model query functions. This set of functions is required to manage element distributed loads with LCase. A LCase object is instanced and the GridFun object is set in it using vis_LCaseSetObject. A concentrated nodal force is defined with vis_LCaseSetConc. Element face distributed loads are defined with vis_LCaseSetDist and finally overall model accelerations are defined using vis_LCaseSetAccel. The concentrated nodal loads are queried and printed by first using vis_LCaseNodeGroup to fill a node group with the nodes at which concentrated loads have been defined. Then a loop over the nodes in the node group is entered. Specific concentrated loads are queried by calling vis_LCaseConcType and vis_LCaseConc in succession. The procedure for querying distributed element face and edge loads is similar. Use vis_LCaseFaceGroup and vis_LCaseEdgeGroup to fill element face and edge groups with the entities which have had distributed loads defined. Then loop over the respective group calling vis_LCaseDistType and vis_LCaseDist in succession to query for the actual distributed load types, coordinate systems and values.

#include <stdio.h>
#include "base/base.h"
#include "vis/vis.h"
/*
                 5------6
                /.     /.\
  y            / .    / . \
  |           /  .   /  .  \7------8
  --x        /   1../...2../|      |
 /         12-----13-----14 |      |
z           |  .   |  .   |.|      |
            | .    | .    | 3------4
            |.     |.     |/
            9-----10-----11
*/

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

#define MAX_ELEM  3
#define MAX_NODE 14

static Vint conn[MAX_ELEM][8] = {
   {1, 2, 6, 5, 9,10,13,12},
   {2, 3, 7, 6,10,11,14,13},
   {3, 4, 8, 7, 0, 0, 0, 0} };

static Vint shap[MAX_ELEM] = {
   VIS_SHAPEHEX, VIS_SHAPEHEX, VIS_SHAPEQUAD };

static Vfloat coords[MAX_NODE][3] = {
   {0.,0.,0.},  {1.,0.,0.},  {2.,0.,1.},  {3.,0.,1.}, 
   {0.,1.,0.},  {1.,1.,0.},  {2.,1.,1.},  {3.,1.,1.}, 
   {0.,0.,2.},  {1.,0.,2.},  {2.,0.,2.},
   {0.,1.,2.},  {1.,1.,2.},  {2.,1.,2.} };

/*----------------------------------------------------------------------
                      Manage Loads Using LCase
----------------------------------------------------------------------*/
int
main()
{
   vis_Connect *connect;
   vis_GridFun *gf;
   vis_LCase *lcase;
   vis_Group *nodegroup, *facegroup, *edgegroup, *elemgroup;
   Vint i, j;
   Vfloat force[3], dist[3*4], body[3*8];
   Vint index, no, flags;
   Vint numtypes, types[3];
   Vfloat values[3*8];
   Vfloat grav[3], cent[3], w[3], wdot[3];

                   /* create connect object */
   connect = vis_ConnectBegin ();
   vis_ConnectDef (connect,MAX_NODE,MAX_ELEM);

                   /* set topologies */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetTopology (connect,i+1,shap[i],2,0,0);
   }

                   /* set element node connectivity */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetElemNode (connect,i+1,conn[i]);
   }

                   /* set node coordinates */ 
   for(i = 0; i < MAX_NODE; i++) {
      vis_ConnectSetCoords (connect,i+1,coords[i]);
   }
                   /* create gridfun object */
   gf = vis_GridFunBegin ();
   vis_ConnectGridFun (connect,gf);

                   /* instance LCase object */ 
   lcase = vis_LCaseBegin ();
   vis_LCaseSetObject (lcase,VIS_GRIDFUN,gf);

                   /* specify concentrated nodal load at node 2 */ 
   force[0] = 1.;
   force[1] = 2.;
   force[2] = 3.;
   vis_LCaseSetConc (lcase,2,LCASE_FORCE,force);

                   /* specify constant pressure on face 2 of element 1 */ 
   dist[0] = 100.;
   dist[1] = 100.;
   dist[2] = 100.;
   dist[3] = 100.;
   vis_LCaseSetDist (lcase,SYS_FACE,1,2,LCASE_PRES,dist);

                   /* specify tractions on nodes of face 3 of element 2 */ 
   dist[0] = 200.;
   dist[1] = 0.;
   dist[2] = 0.;
   dist[3] = 200.;
   dist[4] = 0.;
   dist[5] = 0.;
   dist[6] = 150.;
   dist[7] = 0.;
   dist[8] = 0.;
   dist[9] = 150.;
   dist[10] = 0.;
   dist[11] = 0.;
   vis_LCaseSetDist (lcase,SYS_FACE,2,3,LCASE_TRAC,dist);

                   /* specify varying moment along edge 1 of element 3 */ 
   dist[0] = 20.;
   dist[1] = 30.;
   vis_LCaseSetDist (lcase,SYS_EDGE,3,1,LCASE_TANGMOMENT,dist);

                   /* body force for element 3 */ 
   body[0] = 100.;
   body[1] = 0.;
   body[2] = 0.;
   body[3] = 200.;
   body[4] = 0.;
   body[5] = 0.;
   body[6] = 200.;
   body[7] = 0.;
   body[8] = 0.;
   body[9] = 100.;
   body[10] = 0.;
   body[11] = 0.;
   vis_LCaseSetElem (lcase,3,LCASE_ACCLELEM,body);

                   /* specify accelerations */ 
   grav[0] = 0.;
   grav[1] = 0.;
   grav[2] = 32.;
   cent[0] = 0.;
   cent[1] = 0.;
   cent[2] = 0.;
   w[0] = 1.;
   w[1] = 0.;
   w[2] = 0.;
   wdot[0] = 0.;
   wdot[1] = 0.;
   wdot[2] = 0.;
   vis_LCaseSetAccel (lcase,grav,cent,w,wdot);

                   /* query concentrated nodal loads */ 
   nodegroup = vis_GroupBegin ();
   vis_GroupDef (nodegroup,MAX_NODE,SYS_NODE,SYS_NONE);
   vis_GroupClear (nodegroup);

                   /* group of nodes with concentrated loads */
   vis_LCaseNodeGroup (lcase,NULL,nodegroup);

                   /* iterate through node group */ 
   printf("\nConcentrated Loads\n");
   vis_GroupInitIndex (nodegroup);
   while(vis_GroupNextIndex (nodegroup,&index,&flags),index) {
      printf("node= %d\n",index);
      vis_LCaseConcType (lcase,index,&numtypes,types);

                   /* loop through load types */ 
      for(i = 0; i < numtypes; i++) {
         vis_LCaseConc (lcase,index,types[i],values);
         printf(" values= %f %f %f\n",values[0],values[1],values[2]);
      }
   }
                   /* query element loads */
   elemgroup = vis_GroupBegin ();
   vis_GroupDef (elemgroup,MAX_ELEM,SYS_ELEM,SYS_NONE);
   vis_GroupClear (elemgroup);

                   /* group of elements with element body loads */
   vis_LCaseElemGroup (lcase,NULL,elemgroup);

                   /* iterate through element group */
   printf("\nElement Loads\n");
   vis_GroupInitIndex (elemgroup);
   while(vis_GroupNextIndex (elemgroup,&index,&flags),index) {
      printf("elem= %d\n",index);
      vis_LCaseElemType (lcase,index,&numtypes,types);

                   /* loop through load types */
      for(i = 0; i < numtypes; i++) {
         vis_LCaseElem (lcase,index,types[i],values);
         for(j = 0; j < 4; j++) {
            printf(" %f %f %f\n",values[3*j],values[3*j+1],values[3*j+2]);
         }
      }
   }
                   /* query element face distributed loads */ 
   facegroup = vis_GroupBegin ();
   vis_GroupDef (facegroup,MAX_ELEM,SYS_ELEM,SYS_FACE);
   vis_GroupClear (facegroup);

                   /* group of element faces with distributed loads */
   vis_LCaseFaceGroup (lcase,NULL,facegroup);

                   /* iterate through element face group */ 
   printf("\nElement Face Loads\n");
   vis_GroupInitIndex (facegroup);
   while(vis_GroupNextIndex (facegroup,&index,&flags),index) {
      printf("elem= %d\n",index);

                   /* loop through faces */ 
      for(no = 1; no <= 6; no++) {
         if(VIEW_FLAG(flags,no) == 0) continue;
         printf(" face= %d\n",no);
         vis_LCaseDistType (lcase,SYS_FACE,index,no,&numtypes,types);

                   /* loop through load types */ 
         for(i = 0; i < numtypes; i++) {
            vis_LCaseDist (lcase,SYS_FACE,index,no,types[i],0,values);
            if(types[i] == LCASE_PRES) {
               printf("  type= Pressure\n");
               for(j = 0; j < 4; j++) {
                  printf(" %f\n",values[j]);
               }
            } else if(types[i] == LCASE_TRAC) {
               printf("  type= Traction\n");
               for(j = 0; j < 4; j++) {
                  printf(" %f %f %f\n",values[3*j],values[3*j+1],values[3*j+2]);
               }
            }
         }
      }
   }

                   /* query element edge distributed loads */
   edgegroup = vis_GroupBegin ();
   vis_GroupDef (edgegroup,MAX_ELEM,SYS_ELEM,SYS_EDGE);
   vis_GroupClear (edgegroup);

                   /* group of element edges with distributed loads */
   vis_LCaseEdgeGroup (lcase,NULL,edgegroup);

                   /* iterate through element edge group */
   printf("\nElement Edge Loads\n");
   vis_GroupInitIndex (edgegroup);
   while(vis_GroupNextIndex (edgegroup,&index,&flags),index) {
      printf("elem= %d\n",index);

                   /* loop through edges */
      for(no = 1; no <= 12; no++) {
         if(VIEW_FLAG(flags,no) == 0) continue;
         printf(" edge= %d\n",no);
         vis_LCaseDistType (lcase,SYS_EDGE,index,no,&numtypes,types);

                   /* loop through load types */
         for(i = 0; i < numtypes; i++) {
            vis_LCaseDist (lcase,SYS_EDGE,index,no,types[i],0,values);
            if(types[i] == LCASE_TANGMOMENT) {
               printf("  type= Tangent Moment\n");
               for(j = 0; j < 2; j++) {
                  printf(" %f\n",values[j]);
               }
            }
         }
      }
   }

                   /* end objects */ 
   vis_ConnectEnd (connect);
   vis_GridFunEnd (gf);
   vis_LCaseEnd (lcase);
   vis_GroupEnd (nodegroup);
   vis_GroupEnd (elemgroup);
   vis_GroupEnd (facegroup);
   vis_GroupEnd (edgegroup);
   return 0;
}

Table of Contents

25.24 Example 32a, Manage Contact Pairs Using CPair

This example illustrates the use of a CPair object to manage pairs of contacting surfaces on a small finite element model consisting of two 8-node hexahedra and one 4-node quadrilateral. The model is loaded into a Connect object. A GridFun object is instanced and loaded with model query functions. This set of functions is required to manage element based surfaces with CPair. A CPair object is instanced and the GridFun object is set in it using vis_CPairSetObject. In this example the master surface is to be defined as an element face while the slave "surface" is to defined as a set of nodes. The function vis_CPairDef is used to indicate the entity type to be used to define the master and slave surfaces. A master surface is defined as face 1 of solid element 2 using vis_CPairSetMaster. A slave surface is defined as nodes 4 and 8 using vis_CPairSetSlaveNode.

The slave surface nodes are queried and printed by first using vis_CPairNodeGroup to fill a node group with the nodes defined on the slave surface. Then a loop over the nodes in the node group is entered in which vis_CPairSlaveNode is called to query the slave node area. The master surface element faces are queried by calling vis_CPairFaceGroup.

#include <stdio.h>
#include "base/base.h"
#include "vis/vis.h"
/*
                 5------6
                /.     /.\
  y            / .    / . \
  |           /  .   /  .  \7      8-----16
  --x        /   1../...2../|      |      |
 /         12-----13-----14 |      |      |
z           |  .   |  .   |.|      |      |
            | .    | .    | 3      4-----15
            |.     |.     |/
            9-----10-----11
*/

#define MAX_ELEM  3
#define MAX_NODE 16

static Vint conn[MAX_ELEM][8] = {
   {1, 2, 6, 5, 9,10,13,12},
   {2, 3, 7, 6,10,11,14,13},
   {4,15,16, 8, 0, 0, 0, 0} };

static Vint shap[MAX_ELEM] = {
   VIS_SHAPEHEX, VIS_SHAPEHEX, VIS_SHAPEQUAD };

static Vfloat coords[MAX_NODE][3] = {
   {0.,0.,0.},  {1.,0.,0.},  {2.,0.,1.},  {3.,0.,1.}, 
   {0.,1.,0.},  {1.,1.,0.},  {2.,1.,1.},  {3.,1.,1.}, 
   {0.,0.,2.},  {1.,0.,2.},  {2.,0.,2.},
   {0.,1.,2.},  {1.,1.,2.},  {2.,1.,2.},
   {4.,0.,1.},  {4.,1.,1.} };

/*----------------------------------------------------------------------
                      Manage Contact Pairs Using CPair
----------------------------------------------------------------------*/
int
main()
{
   Vint i;
   vis_Connect *connect;
   vis_GridFun *gf;
   vis_CPair *cpair;
   vis_IdTran *nodeidtran, *faceidtran;
   Vdouble area;
   Vint index, num, no;

                   /* create connect object */
   connect = vis_ConnectBegin ();
   vis_ConnectDef (connect,MAX_NODE,MAX_ELEM);

                   /* set topologies */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetTopology (connect,i+1,shap[i],2,0,0);
   }
                   /* set element node connectivity */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetElemNode (connect,i+1,conn[i]);
   }
                   /* set node coordinates */ 
   for(i = 0; i < MAX_NODE; i++) {
      vis_ConnectSetCoords (connect,i+1,coords[i]);
   }
                   /* create gridfun object */
   gf = vis_GridFunBegin ();
   vis_ConnectGridFun (connect,gf);

                   /* instance CPair object */ 
   cpair = vis_CPairBegin ();

                   /* master surface is defined by element faces */ 
                   /* slave surface is defined by nodes */ 
   vis_CPairDef (cpair,SYS_FACE,SYS_NODE);
   vis_CPairSetObject (cpair,VIS_GRIDFUN,gf);

                   /* specify master surface as element faces */
   vis_CPairSetMaster (cpair,2,1);

                   /* specify slave surface as nodes */
   vis_CPairSetSlaveNodedv (cpair,4,1.);
   vis_CPairSetSlaveNodedv (cpair,8,1.);

                   /* define properties */ 
   vis_CPairSetValuei (cpair,CPAIR_PID,20);
                   /* Adjust parameter */
   vis_CPairSetValued (cpair,CPAIR_ADJUST,.1);

                   /* query slave nodes */
   nodeidtran = vis_IdTranBegin ();
                   /* slave nodes */
   vis_CPairNodeIdTran (cpair,nodeidtran);

                   /* iterate through nodes */
   printf("\nSlave Nodes\n");
   vis_IdTranCount (nodeidtran,IDTRAN_NUMINDICES,&num);
   for(i = 1; i <= num; i++) {
      vis_IdTranGetId (nodeidtran,i,&index);
      vis_CPairSlaveNodedv (cpair,index,&area);
      printf("node= %d, area= %e\n",index,area);
   }

                   /* query master element faces */
   faceidtran = vis_IdTranBegin ();
                   /* element faces */
   vis_CPairFaceIdTran (cpair,CPAIR_MASTER,faceidtran);

                   /* iterate through element faces */
   printf("\nMaster Element Faces\n");
   vis_IdTranCount (faceidtran,IDTRAN_NUMINDICES,&num);
   for(i = 1; i <= num; i++) {
      vis_IdTranGetId (faceidtran,i,&index);
      vis_IdTranGetEnt (faceidtran,i,&no);
      printf("elem= %d, face= %d\n",index,no);
   }

                   /* end objects */ 
   vis_ConnectEnd (connect);
   vis_GridFunEnd (gf);
   vis_CPairEnd (cpair);
   vis_IdTranEnd (nodeidtran);
   vis_IdTranEnd (faceidtran);
   return 0;
}

Table of Contents

25.25 Example 32b, Manage Analytic Surfaces using ASurf

This example illustrates the use of the ASurf object to manage analytic surfaces. Three ASurf objects are instanced and placed into a HashTable. The three analytic surfaces are a sphere, a plane of finite extent and a surface of revolution. Most analytic surfaces are orientable (the exception is the sphere). In the case of a segmented surface, the input points, defined using vis_ASurfSetPoint, are in this oriented local coordinate system.

The ASurf objects in the HashTable are then traversed and the appropriate query functions are using to access the analytic surface information and print it to standard output.

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

/*----------------------------------------------------------------------
                      Manage Analytic Surfaces using ASurf
----------------------------------------------------------------------*/
int
main()
{
   Vint i;
   vsy_HashTable *ht;
   vis_ASurf *asurf;
   Vfloat x[3], r;
   Vfloat a[3], b[3], c[3], length, width;
   Vint type, id, segtype;
   Vint ix[3], numpnt, numseg;

                   /* create HashTable to hold ASurf objects */
   ht = vsy_HashTableBegin ();
                   /* create ASurf object for a sphere */ 
   asurf = vis_ASurfBegin ();
   vis_ASurfDef (asurf,ASURF_SPHERE);
   x[0] = 0.; x[1] = 1.; x[2] = 1.;
   r = 2.;
   vis_ASurfSetSphere (asurf,x,r);
   vsy_HashTableInsert (ht,10,asurf);
                   /* create ASurf object for a plane */ 
   asurf = vis_ASurfBegin ();
   vis_ASurfDef (asurf,ASURF_PLANE);
   a[0] = 0.; a[1] = 0.; a[2] = 0.;
   b[0] = 1.; b[1] = 0.; b[2] = 0.;
   c[0] = 0.; c[1] = 1.; c[2] = 0.;
   length = 3.;
   width = 4.;
   vis_ASurfSetPlane (asurf,a,b,c,length,width);
   vsy_HashTableInsert (ht,20,asurf);
                   /* create ASurf object for a surface of revolution */ 
   asurf = vis_ASurfBegin ();
   vis_ASurfDef (asurf,ASURF_SEGMENT_REV);
                   /* set local coordinate system */ 
   a[0] = 0.; a[1] = 0.; a[2] = 0.;
   b[0] = 1.; b[1] = 0.; b[2] = 0.;
   c[0] = 0.; c[1] = 1.; c[2] = 0.;
   vis_ASurfSetSegmentRev (asurf,a,b,c);
                   /* points in local x-z plane, revolve about local z axis */
                   /* set points */ 
   x[0] = 2.; x[1] = 0.; x[2] = 0.;
   vis_ASurfSetPoint (asurf,1,x);
   x[0] = 2.; x[1] = 0.; x[2] = 2.;
   vis_ASurfSetPoint (asurf,2,x);
   x[0] = 1.; x[1] = 0.; x[2] = 3.;
   vis_ASurfSetPoint (asurf,3,x);
                   /* circle center */ 
   x[0] = 1.; x[1] = 0.; x[2] = 2.;
   vis_ASurfSetPoint (asurf,4,x);
                   /* set segments */ 
   ix[0] = 1;
   ix[1] = 2;
   vis_ASurfSetSegment (asurf,1,ASURF_SEG_LINE,ix);
   ix[0] = 2;
   ix[1] = 4;
   ix[2] = 3;
   vis_ASurfSetSegment (asurf,2,ASURF_SEG_ARC,ix);
   vsy_HashTableInsert (ht,30,asurf);

                   /* loop through HashTable */ 
   vsy_HashTableInitIter (ht);
   while(vsy_HashTableNextIter(ht,&id,(Vobject**)&asurf),asurf) {
      vis_ASurfInq (asurf,&type);
      if(type == ASURF_SPHERE) {
         vis_ASurfGetSphere (asurf,x,&r);
         printf("Sphere, id= %d, x= %f %f %f, r= %f\n",id,x[0],x[1],x[2],r);
      } else if(type == ASURF_PLANE) {
         vis_ASurfGetPlane (asurf,a,b,c,&length,&width);
         printf("Plane, id= %d, a= %f %f %f\n",id,a[0],a[1],a[2]);
         printf("               b= %f %f %f\n",b[0],b[1],b[2]);
         printf("               c= %f %f %f\n",c[0],c[1],c[2]);
         printf("               length= %f, width= %f\n",length,width);
      } else if(type == ASURF_SEGMENT_REV) {
         vis_ASurfNumPoints (asurf,&numpnt);
         vis_ASurfNumSegments (asurf,&numseg);
         printf("Segment Rev, id= %d, numpnts= %d, numseg= %d\n",
                              id,numpnt,numseg);
         vis_ASurfGetSegmentRev (asurf,a,b,c);
         printf("             a= %f %f %f\n",a[0],a[1],a[2]);
         printf("             b= %f %f %f\n",b[0],b[1],b[2]);
         printf("             c= %f %f %f\n",c[0],c[1],c[2]);
         for(i = 1; i <= numpnt; i++) {
            vis_ASurfGetPoint (asurf,i,x);
            printf(" point, id= %d, x= %f %f %f\n",i,x[0],x[1],x[2]);
         }
         for(i = 1; i <= numseg; i++) {
            vis_ASurfGetSegment (asurf,i,&segtype,ix);
            if(segtype == ASURF_SEG_LINE) {
               printf(" seg line, id= %d, ix= %d %d\n",i,ix[0],ix[1]);
            } else if(segtype == ASURF_SEG_ARC) {
               printf(" seg arc,  id= %d, ix= %d %d %d\n",i,ix[0],ix[1],ix[2]);
            }
         }
      }
   }
                   /* end objects */ 
   vsy_HashTableForEach (ht,(void(*)(void*))vis_ASurfEnd);
   vsy_HashTableEnd (ht);
   return 0;
}

Table of Contents

25.26 Example 32c, Manage Complex Loads Using LCase

This example is a modification of Example 32 and illustrates the use of a LCase object to manage complex valued concentrated nodal loads and distributed element loads. In this example double precision functions are used.

Complex valued loads are specified using the same functions as real valued loads. The function vis_LCaseSetComplexMode is used to place the LCase object in the mode to expect either the real and/or imaginary parts of a complex number in all functions which set or query nodal concentrated and element distributed load value. In this case the real and imaginary parts are to be entered simultaneously so the complex mode is set to SYS_COMPLEX_REALIMAGINARY.

#include <stdio.h>
#include "base/base.h"
#include "vis/vis.h"
/*
                 5------6
                /.     /.\
  y            / .    / . \
  |           /  .   /  .  \7------8
  --x        /   1../...2../|      |
 /         12-----13-----14 |      |
z           |  .   |  .   |.|      |
            | .    | .    | 3------4
            |.     |.     |/
            9-----10-----11
*/

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

#define MAX_ELEM  3
#define MAX_NODE 14

static Vint conn[MAX_ELEM][8] = {
   {1, 2, 6, 5, 9,10,13,12},
   {2, 3, 7, 6,10,11,14,13},
   {3, 4, 8, 7, 0, 0, 0, 0} };

static Vint shap[MAX_ELEM] = {
   VIS_SHAPEHEX, VIS_SHAPEHEX, VIS_SHAPEQUAD };

static Vfloat coords[MAX_NODE][3] = {
   {0.,0.,0.},  {1.,0.,0.},  {2.,0.,1.},  {3.,0.,1.}, 
   {0.,1.,0.},  {1.,1.,0.},  {2.,1.,1.},  {3.,1.,1.}, 
   {0.,0.,2.},  {1.,0.,2.},  {2.,0.,2.},
   {0.,1.,2.},  {1.,1.,2.},  {2.,1.,2.} };

/*----------------------------------------------------------------------
                      Manage Complex Loads Using LCase
----------------------------------------------------------------------*/
int
main()
{
   vis_Connect *connect;
   vis_GridFun *gf;
   vis_LCase *lcase;
   vis_Group *nodegroup, *facegroup, *edgegroup, *elemgroup;
   Vint i, j;
   Vdouble formom[2*6], dist[2*3*4], body[2*3*8];
   Vint index, no, flags;
   Vint numtypes, types[3];
   Vdouble values[2*3*8];
   Vint tid[2];
                   /* create connect object */
   connect = vis_ConnectBegin ();
   vis_ConnectDef (connect,MAX_NODE,MAX_ELEM);

                   /* set topologies */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetTopology (connect,i+1,shap[i],2,0,0);
   }
                   /* set element node connectivity */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetElemNode (connect,i+1,conn[i]);
   }
                   /* set node coordinates */ 
   for(i = 0; i < MAX_NODE; i++) {
      vis_ConnectSetCoords (connect,i+1,coords[i]);
   }
                   /* create gridfun object */
   gf = vis_GridFunBegin ();
   vis_ConnectGridFun (connect,gf);

                   /* instance LCase object */ 
   lcase = vis_LCaseBegin ();
   vis_LCaseSetObject (lcase,VIS_GRIDFUN,gf);

                   /* real and imaginary parts */
   vis_LCaseSetComplexMode (lcase,SYS_COMPLEX_REALIMAGINARY);
                   /* specify concentrated nodal force and moment at node 2 */ 
   formom[0] = 1.;  formom[1] = 11.;
   formom[2] = 2.;  formom[3] = 21.;
   formom[4] = 3.;  formom[5] = 31.;
   vis_LCaseSetConcdv (lcase,2,LCASE_FORCE,formom);
   formom[0] = 4.;  formom[1] = 41.;
   formom[2] = 5.;  formom[3] = 51.;
   formom[4] = 6.;  formom[5] = 61.;
   vis_LCaseSetConcdv (lcase,2,LCASE_MOMENT,formom);

                   /* specify pressure on face 2 of element 1 */ 
   dist[0] = 100.;  dist[1] = 101.;
   dist[2] = 200.;  dist[3] = 201.;
   dist[4] = 300.;  dist[5] = 301.;
   dist[6] = 400.;  dist[7] = 401.;
   vis_LCaseSetDistdv (lcase,SYS_FACE,1,2,LCASE_PRES,dist);
                   /* set specific table id's for real/imaginary parts */ 
   tid[0] = 1;
   tid[1] = 2;
   vis_LCaseSetDistTId (lcase,SYS_FACE,1,2,LCASE_PRES,tid);

                   /* specify varying moment along edge 1 of element 3 */ 
   dist[0] = 20.;  dist[1] = 30.;
   dist[2] = 21.;  dist[3] = 31.;
   vis_LCaseSetDistdv (lcase,SYS_EDGE,3,1,LCASE_TANGMOMENT,dist);

                   /* body force for element 3,
                      complex vector at each of 4 nodes on element */ 
   body[0] = 100.; body[1] = 101.;
   body[2] = 0.;   body[3] = 0.;
   body[4] = 0.;   body[5] = 0.;
   body[6] = 200.; body[7] = 201.;
   body[8] = 0.;   body[9] = 0.;
   body[10] = 0.;  body[11] = 0.;
   body[12] = 200.; body[13] = 201.;
   body[14] = 0.;   body[15] = 0.;
   body[16] = 0.;   body[17] = 0.;
   body[18] = 100.; body[19] = 101.;
   body[20] = 0.;   body[21] = 0.;
   body[22] = 0.;   body[23] = 0.;
   vis_LCaseSetElemdv (lcase,3,LCASE_ACCLELEM,body);

                   /* query concentrated nodal loads */ 
   nodegroup = vis_GroupBegin ();
   vis_GroupDef (nodegroup,MAX_NODE,SYS_NODE,SYS_NONE);
   vis_GroupClear (nodegroup);

                   /* group of nodes with concentrated loads */
   vis_LCaseNodeGroup (lcase,NULL,nodegroup);

                   /* iterate through node group */ 
   printf("\nConcentrated Loads\n");
   vis_GroupInitIndex (nodegroup);
   while(vis_GroupNextIndex (nodegroup,&index,&flags),index) {
      printf("node= %d\n",index);
      vis_LCaseConcType (lcase,index,&numtypes,types);

                   /* loop through load types */ 
      for(i = 0; i < numtypes; i++) {
         vis_LCaseConcdv (lcase,index,types[i],values);
         printf(" values= %f %f(i) %f %f(i) %f %f(i)\n",
                  values[0],values[1],values[2],values[3],values[4],values[5]);
      }
   }
                   /* query element loads */
   elemgroup = vis_GroupBegin ();
   vis_GroupDef (elemgroup,MAX_ELEM,SYS_ELEM,SYS_NONE);
   vis_GroupClear (elemgroup);

                   /* group of elements with element body loads */
   vis_LCaseElemGroup (lcase,NULL,elemgroup);

                   /* iterate through element group */
   printf("\nElement Loads\n");
   vis_GroupInitIndex (elemgroup);
   while(vis_GroupNextIndex (elemgroup,&index,&flags),index) {
      printf("elem= %d\n",index);
      vis_LCaseElemType (lcase,index,&numtypes,types);

                   /* loop through load types */
      for(i = 0; i < numtypes; i++) {
         vis_LCaseElemdv (lcase,index,types[i],values);
         for(j = 0; j < 4; j++) {
            printf(" %f %f(i) %f %f(i) %f %f(i)\n",
                    values[2*3*j],values[2*3*j+1],values[2*3*j+2],
                    values[2*3*j+3],values[2*3*j+4],values[2*3*j+5]);
         }
      }
   }
                   /* query element face distributed loads */ 
   facegroup = vis_GroupBegin ();
   vis_GroupDef (facegroup,MAX_ELEM,SYS_ELEM,SYS_FACE);
   vis_GroupClear (facegroup);

                   /* group of element faces with distributed loads */
   vis_LCaseFaceGroup (lcase,NULL,facegroup);

                   /* iterate through element face group */ 
   printf("\nElement Face Loads\n");
   vis_GroupInitIndex (facegroup);
   while(vis_GroupNextIndex (facegroup,&index,&flags),index) {
      printf("elem= %d\n",index);

                   /* loop through faces */ 
      for(no = 1; no <= 6; no++) {
         if(VIEW_FLAG(flags,no) == 0) continue;
         printf(" face= %d\n",no);
         vis_LCaseDistType (lcase,SYS_FACE,index,no,&numtypes,types);

                   /* loop through load types */ 
         for(i = 0; i < numtypes; i++) {
            vis_LCaseDistdv (lcase,SYS_FACE,index,no,types[i],0,values);
            vis_LCaseDistTId (lcase,SYS_FACE,index,no,types[i],tid);
            if(types[i] == LCASE_PRES) {
               printf("  type= Pressure\n");
               for(j = 0; j < 4; j++) {
                  printf(" %f %f(i)\n",values[2*j],values[2*j+1]);
               }
               printf(" %d %d(i)\n",tid[0],tid[1]);
            } else if(types[i] == LCASE_TRAC) {
               printf("  type= Traction\n");
               for(j = 0; j < 4; j++) {
                  printf(" %f %f(i) %f %f(i) %f %f(i)\n",
                    values[2*3*j],values[2*3*j+1],values[2*3*j+2],
                    values[2*3*j+3],values[2*3*j+4],values[2*3*j+5]);
               }
            }
         }
      }
   }

                   /* query element edge distributed loads */
   edgegroup = vis_GroupBegin ();
   vis_GroupDef (edgegroup,MAX_ELEM,SYS_ELEM,SYS_EDGE);
   vis_GroupClear (edgegroup);

                   /* group of element edges with distributed loads */
   vis_LCaseEdgeGroup (lcase,NULL,edgegroup);

                   /* iterate through element edge group */
   printf("\nElement Edge Loads\n");
   vis_GroupInitIndex (edgegroup);
   while(vis_GroupNextIndex (edgegroup,&index,&flags),index) {
      printf("elem= %d\n",index);

                   /* loop through edges */
      for(no = 1; no <= 12; no++) {
         if(VIEW_FLAG(flags,no) == 0) continue;
         printf(" edge= %d\n",no);
         vis_LCaseDistType (lcase,SYS_EDGE,index,no,&numtypes,types);

                   /* loop through load types */
         for(i = 0; i < numtypes; i++) {
            vis_LCaseDistdv (lcase,SYS_EDGE,index,no,types[i],0,values);
            if(types[i] == LCASE_TANGMOMENT) {
               printf("  type= Tangent Moment\n");
               for(j = 0; j < 2; j++) {
                  printf(" %f %f(i)\n",values[2*j],values[2*j+1]);
               }
            }
         }
      }
   }
                   /* end objects */ 
   vis_ConnectEnd (connect);
   vis_GridFunEnd (gf);
   vis_LCaseEnd (lcase);
   vis_GroupEnd (nodegroup);
   vis_GroupEnd (elemgroup);
   vis_GroupEnd (facegroup);
   vis_GroupEnd (edgegroup);
   return 0;
}

Table of Contents

25.27 Example 33, Manage Constraints Using RCase and MCase

This example illustrates the use of RCase and MCase objects to manage single point constraints (SPC's) at nodes and general constraints, including multipoint (MPC's) respectively. Three SPC's are defined: a translational fixity at node 2, an applied rotation at node 4, and a y-rotation equivalence of node 4 to node 2. These SPC's are defined using vis_RCaseSetSPC. Two MPC's are defined between the x and y translation of nodes 5, 100 and 101. The MPC's represent constraining node 5 to displace as the average of nodes 100 and 101. In addition, a third built-in tie constraint is defined. The SPC's are queried and printed by first using vis_RCaseNodeGroup to fill a node group with the nodes at which SPC's have been defined. Then a loop over the nodes in the node group is entered. Specific SPC tags and information are queried by calling vis_RCaseSPCTag and vis_RCaseSPC in succession. The technique for querying and printing constraints involves finding the maximum constraint number defined using vis_MCaseMax and then looping over the range of constraints and querying for the constraint type and specific type information using vis_MCaseMPC and vis_MCaseCon Any undefined constraint will return nterms equal to zero.

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

/*----------------------------------------------------------------------
                      Manage Constraints Using RCase and MCase
----------------------------------------------------------------------*/
int
main()
{
   vis_RCase *rcase;
   vis_MCase *mcase;
   vis_Group *nodegroup;
   Vint i;
   Vint index;
   Vint numtags, tag[SYS_DOF_MAX];
   Vint flags, type, master;
   Vfloat value;
   Vint ix[3], ig[3];
   Vfloat c[3], r;
   Vint maxindex, maxterms, maxrhs, nterms;

                   /* instance RCase object */ 
   rcase = vis_RCaseBegin ();

                   /* Define SPC's */ 
                   /* specify x translation fixity at node 2 */
   vis_RCaseSetSPC (rcase,2,SYS_DOF_TX,RCASE_FIXED,NULL,0);

                   /* specify applied x rotation at node 4 */
   value = 1.;
   vis_RCaseSetSPC (rcase,4,SYS_DOF_RX,RCASE_APPLIED,&value,0);

                   /* specify master for y rotation at node 4 */
   vis_RCaseSetSPC (rcase,4,SYS_DOF_RY,RCASE_MASTER,NULL,2);

                   /* instance MCase object */ 
   mcase = vis_MCaseBegin ();

                   /* Define MPC's */ 
   ix[0] = 5;
   ix[1] = 100;
   ix[2] = 101;
   ig[0] = SYS_DOF_TX;
   ig[1] = SYS_DOF_TX;
   ig[2] = SYS_DOF_TX;
   c[0] = -1.;
   c[1] = .5;
   c[2] = .5;
   vis_MCaseSetMPC (mcase,1,3,ix,ig,c,0.);
   ig[0] = SYS_DOF_TY;
   ig[1] = SYS_DOF_TY;
   ig[2] = SYS_DOF_TY;
   vis_MCaseSetMPC (mcase,2,3,ix,ig,c,0.);
                   /* define a Tie */ 
   ix[0] = 2;
   ix[1] = 3;
   vis_MCaseSetCon (mcase,3,MCASE_TIE,ix);

                   /* query SPC's */
   nodegroup = vis_GroupBegin ();
   vis_GroupDef (nodegroup,4,SYS_NODE,SYS_NONE);
   vis_GroupClear (nodegroup);

                   /* group of nodes with single point constraints */
   vis_RCaseNodeGroup (rcase,NULL,nodegroup);

                   /* iterate through node group */ 
   printf("\nSingle Point Constraints\n");
   vis_GroupInitIndex (nodegroup);
   while(vis_GroupNextIndex (nodegroup,&index,&flags),index) {
      printf("node= %d\n",index);
      vis_RCaseSPCTag (rcase,index,&numtags,tag);
      for(i = 0; i < numtags; i++) {
         vis_RCaseSPC (rcase,index,tag[i],&type,&value,&master);
         printf("tag= %d, type= %d\n",tag[i],type);
         if(type == RCASE_APPLIED) {
            printf(" value= %f\n",value);
         } else if(type == RCASE_MASTER) {
            printf(" master= %d\n",master);
         }
      }
   }
                   /* query MPC's */ 
   vis_MCaseMax (mcase,&maxindex,&maxterms,&maxrhs);

   printf("\nMultiPoint Constraints\n");
   for(index = 1; index <= maxindex; index++) {
      vis_MCaseNum (mcase,index,&nterms);
      vis_MCaseType (mcase,index,&type);
      if(nterms) {
         if(type == MCASE_MPC) {
            vis_MCaseMPC (mcase,index,&nterms,ix,ig,c,&r);
            printf("index= %d, nterms= %d, r= %f\n",index,nterms,r);
            for(i = 0; i < nterms; i++) {
               printf(" ix= %d, tag= %d, c= %f\n",ix[i],ig[i],c[i]);
            }
         } else {
            vis_MCaseCon (mcase,index,&type,&nterms,ix);
            printf("index= %d, type= %d, nterms= %d\n",index,type,nterms);
            for(i = 0; i < nterms; i++) {
               printf(" ix= %d\n",ix[i]);
            }
         }
      }
   }
                   /* end objects */ 
   vis_RCaseEnd (rcase);
   vis_MCaseEnd (mcase);
   vis_GroupEnd (nodegroup);
   return 0;
}

Table of Contents

25.28 Example 33a, Manage Initial Conditions Using ICase

This example illustrates the use of an ICase object to manage initial conditions at nodes. It is recommended that all initial condition values at a node be defined with a single call to vis_ICaseSetSPV. Assuming that only translational degrees of freedom are to have initial conditions defined, the tag array is initialized with the three translational degree of freedom types. Initial displacements are then defined at two nodes, nodes 3 and 10, and initial velocities at one node, node 2. The initial conditions are queried and printed by first using vis_ICaseNodeGroup to fill a node group with the nodes at which initial conditions have been defined. Then a loop over the nodes in the node group is entered. Specific initial condition types and information are queried by calling vis_ICaseSPVType and vis_ICaseSPV in succession.

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

/*----------------------------------------------------------------------
                      Manage Initial Conditions Using ICase
----------------------------------------------------------------------*/
int
main()
{
   vis_ICase *icase;
   vis_Group *nodegroup;
   Vint i, j;
   Vint index;
   Vint flags;
   Vint ntags, tag[SYS_DOF_MAX];
   Vdouble val[SYS_DOF_MAX];
   Vint ntypes, type[2];

                   /* instance ICase object */ 
   icase = vis_ICaseBegin ();

                   /* specify initial conditions for translational freedoms */
   ntags = 3;
   tag[0] = SYS_DOF_TX;
   tag[1] = SYS_DOF_TY;
   tag[2] = SYS_DOF_TZ;

                   /* initial displacement at nodes 3 and 10 */ 
   val[0] = 1.;
   val[1] = 0.;
   val[2] = 0.;
   vis_ICaseSetSPVdv (icase,3,ICASE_DOF,ntags,tag,val);

   val[0] = -2.;
   val[1] = 0.;
   val[2] = 0.;
   vis_ICaseSetSPVdv (icase,10,ICASE_DOF,ntags,tag,val);

                   /* initial velocity at node 2 */ 
   val[0] = 0.;
   val[1] = 1000.;
   val[2] = 0.;
   vis_ICaseSetSPVdv (icase,2,ICASE_DOFDOT,ntags,tag,val);

                   /* query initial conditions */
   nodegroup = vis_GroupBegin ();
   vis_GroupDef (nodegroup,10,SYS_NODE,SYS_NONE);
   vis_GroupClear (nodegroup);

                   /* group of nodes with initial conditions */
   vis_ICaseNodeGroup (icase,NULL,nodegroup);

                   /* iterate through node group */ 
   printf("\nInitial Conditions\n");
   vis_GroupInitIndex (nodegroup);
   while(vis_GroupNextIndex (nodegroup,&index,&flags),index) {
      printf("node= %d\n",index);
      vis_ICaseSPVType (icase,index,&ntypes,type);
      for(i = 0; i < ntypes; i++) {
         vis_ICaseSPVdv (icase,index,type[i],&ntags,tag,val);
         for(j = 0; j < ntags; j++) {
            printf("tag= %d\n",tag[j]);
            if(type[i] == ICASE_DOF) {
               printf(" dof= %f\n",val[j]);
            } else if(type[i] == ICASE_DOFDOT) {
               printf(" dofdot= %f\n",val[j]);
            }
         }
      }
   }

                   /* end objects */ 
   vis_ICaseEnd (icase);
   vis_GroupEnd (nodegroup);
   return 0;
}

Table of Contents

25.29 Example 33b, Manage Complex Constraints Using RCase

This example illustrates the use of the RCase object to manage time or frequency dependent complex valued single point constraints (SPC's) at nodes. In this example double precision functions are used.

Complex valued constraints are specified using the same functions as real valued constraints. The function vis_RCaseSetComplexMode is used to place the RCase object in the mode to expect either the real and/or imaginary parts of a complex number in all functions which set or query nodal applied constraint values. In this case the real and imaginary parts are to be entered simultaneously so the complex mode is set to SYS_COMPLEX_REALIMAGINARY.

Four SPC's are defined: a translational fixity at node 2, an applied translation at node 3, an applied y-acceleration at node 4 with associated table identifiers for time dependent amplitude, and a y-rotation equivalence of node 7 to node 5. Use vis_RCaseSetSPCDot to specify a constraint time derivative, in this case acceleration. Use vis_RCaseSetSPCTId to set associated table identifiers.

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

/*----------------------------------------------------------------------
                    Manage Complex Constraints Using RCase
----------------------------------------------------------------------*/
int
main()
{
   vis_RCase *rcase;
   vis_Group *nodegroup;
   Vint i;
   Vint index;
   Vint numtags, tag[SYS_DOF_MAX], tid[2], dottype;
   Vint flags, type, master;
   Vdouble value[2];

                   /* instance RCase object */ 
   rcase = vis_RCaseBegin ();

                   /* Define SPC's */ 
                   /* specify x translation fixity at node 2 */
   vis_RCaseSetSPCdv (rcase,2,SYS_DOF_TX,RCASE_FIXED,NULL,0);

                   /* specify applied x translation at node 3 */
   vis_RCaseSetComplexMode (rcase,SYS_COMPLEX_REALIMAGINARY);
   value[0] = 1.;
   value[1] = 2.;
   vis_RCaseSetSPCdv (rcase,3,SYS_DOF_TX,RCASE_APPLIED,value,0);
                   /* specify applied y acceleration at node 4 */
   value[0] = 10.;
   value[1] = 20.;
   vis_RCaseSetSPCdv (rcase,4,SYS_DOF_TY,RCASE_APPLIED,value,0);
   vis_RCaseSetSPCDot (rcase,4,SYS_DOF_TY,RCASE_DOFDOTDOT);
   tid[0] = 30;
   tid[1] = 40;
   vis_RCaseSetSPCTId (rcase,4,SYS_DOF_TY,tid);

                   /* specify master for y rotation at node 5 */
   vis_RCaseSetSPCdv (rcase,7,SYS_DOF_RY,RCASE_MASTER,NULL,5);

                   /* query SPC's */
   nodegroup = vis_GroupBegin ();
   vis_GroupDef (nodegroup,4,SYS_NODE,SYS_NONE);
   vis_GroupClear (nodegroup);

                   /* group of nodes with single point constraints */
   vis_RCaseNodeGroup (rcase,NULL,nodegroup);

                   /* iterate through node group */ 
   printf("\nSingle Point Constraints\n");
   vis_GroupInitIndex (nodegroup);
   while(vis_GroupNextIndex (nodegroup,&index,&flags),index) {
      printf("node= %d\n",index);
      vis_RCaseSPCTag (rcase,index,&numtags,tag);
      for(i = 0; i < numtags; i++) {
         vis_RCaseSPCdv (rcase,index,tag[i],&type,value,&master);
         printf("tag= %d, type= %d\n",tag[i],type);
         if(type == RCASE_APPLIED) {
            vis_RCaseSPCTId (rcase,index,tag[i],tid);
            vis_RCaseSPCDot (rcase,index,tag[i],&dottype);
            printf(" value= %f %f(i)\n",value[0],value[1]);
            printf(" tid= %d %d(i)\n",tid[0],tid[1]);
            printf(" dottype= %d\n",dottype);
         } else if(type == RCASE_MASTER) {
            printf(" master= %d\n",master);
         }
      }
   }
                   /* end objects */ 
   vis_RCaseEnd (rcase);
   vis_GroupEnd (nodegroup);
   return 0;
}

Table of Contents

25.30 Example 34, Manage Element Properties Using EProp

This example illustrates the use of a EProp object to manage element properties for a shell element. The real valued properties are defined and queried in double precision. The element material id and 4 corner thicknesses are defined. Given these element properties the element node thicknesses for an 8 node parabolic shell element are computed and printed using vis_EPropEvaldv. Then the defined element properties are traversed and printed. The number and type of properties defined are first queried using vis_EPropValueType. A loop over the defined types is entered and the name and parameters for each type are queried and printed. The property values are queried using vis_EPropValueInteger and vis_EPropValueDouble.

#include "base/base.h"
#include "vis/vis.h"

/*----------------------------------------------------------------------
                      Manage Element Properties Using EProp
----------------------------------------------------------------------*/
int
main()
{
   Vint i, j, k;
   Vint iparams[1];
   Vdouble dparams[4];
   vis_EProp *eprop;
   Vint ntypes, *type;
   Vint nval, nloc, dtyp;
   Vchar name[64];
   Vdouble cthick[4], thick[8];

                   /* create eprop for shell element properties */ 
   eprop = vis_EPropBegin ();
   vis_EPropDef (eprop,VIS_ELEM_SHELL);

                   /* set material id */ 
   vis_EPropSetValuei (eprop,EPROP_MID,1);

                   /* install corner thicknesses */ 
   cthick[0] = .5;
   cthick[1] = .5;
   cthick[2] = 1.5;
   cthick[3] = 1.5;
   vis_EPropSetValuedv (eprop,EPROP_THICKNESS,cthick);

                   /* compute thicknesses for 8 node shell */ 
   vis_EPropEvaldv (eprop,EPROP_THICKNESS,VIS_SHAPEQUAD,3,0,thick);
   printf("\nElement node thickness:\n");
   for(i = 0; i < 8; i++) {
      printf("thickness= %e\n",thick[i]);
   }
                   /* traverse defined element properties */ 
   vis_EPropValueTypeNum (eprop,&ntypes);
   printf("ntypes = %d\n",ntypes);
   type = (Vint*)malloc(ntypes*sizeof(Vint));
   vis_EPropValueType (eprop,&ntypes,type);

                   /* loop through types */ 
   for(i = 0; i < ntypes; i++) {
      vis_EPropValueName (eprop,type[i],name);
      printf("\n name = %s\n",name);
      vis_EPropValueParams (eprop,type[i],&nval,&nloc,&dtyp);
      printf(" nval= %d, nloc= %d\n",nval,nloc);

                   /* integer valued */ 
      if(dtyp == SYS_INTEGER) {
         printf(" Integer\n");
         vis_EPropValueInteger (eprop,type[i],iparams);
         for(j = 0; j < nval; j++) {
            printf("  value= %d\n",iparams[j]);
         }
                   /* real valued */ 
      } else {
         vis_EPropValueDouble (eprop,type[i],dparams);
         printf(" Real\n");
         for(k = 0; k < nloc; k++) {
            printf(" Location= %d\n",k);
            for(j = 0; j < nval; j++) {
               printf("  value= %e\n",dparams[k*nval+j]);
            }
         }
      }
   }
                   /* end objects */ 
   free(type);
   vis_EPropEnd (eprop);
   return 0;
}

Table of Contents

25.31 Example 34a, Composite Shell and General Beam Property Using EProp

This example illustrates the use of a EProp object to manage composite shell and general beam properties. The properties in this example are assumed to be constant over the shell surface and along the length of the beam. In general they may vary over the shell and beam elements. The orientation angles of the shell layers are relative to the shell local coordinate system in the plane of the shell.

#include "base/base.h"
#include "vis/vis.h"

static void
print_EProp(vis_EProp *eprop);

/*----------------------------------------------------------------------
                      Composite Shell and General Beam Property Using EProp
----------------------------------------------------------------------*/
int
main()
{
   vis_EProp *eprop, *epropb;
   Vint nlay, mid[4];
   Vdouble thk[4], phi[4];
   Vint midb;
   Vdouble a, iyy, izz, j, asy, asz, cw;
                   /* create eprop for shell element composite property */ 
   eprop = vis_EPropBegin ();
   vis_EPropDef (eprop,VIS_ELEM_SHELL);
   vis_EPropSetValuei (eprop,EPROP_SHELLWALL,SYS_SHELLWALL_LAMINATE);
                   /* 4 layers */ 
   nlay = 4;
                   /* material ids */
   mid[0] = 1;
   mid[1] = 2;
   mid[2] = 2;
   mid[3] = 1;
                   /* thicknesses */
   thk[0] = .2;
   thk[1] = .1;
   thk[2] = .1;
   thk[3] = .2;
                   /* layup angles in degrees */
   phi[0] = 0.;
   phi[1] = 45.;
   phi[2] = -45.;
   phi[3] = 0.;
   vis_EPropSetValuei (eprop,EPROP_LAYER_NUM,nlay);
   vis_EPropSetValueiv (eprop,EPROP_LAYER_MID,mid);
   vis_EPropSetValuedv (eprop,EPROP_LAYER_THK,thk);
   vis_EPropSetValuedv (eprop,EPROP_LAYER_PHI,phi);
                   /* set optional eccentricity */
   vis_EPropSetValued (eprop,EPROP_ECC,.3);
                   /* print contents of shell EProp */
   print_EProp (eprop);

                   /* create eprop for general beam element property */ 
   epropb = vis_EPropBegin ();
   vis_EPropDef (epropb,VIS_ELEM_BEAM);
   vis_EPropSetValuei (epropb,EPROP_BEAMSECT,SYS_BEAMSECT_PROPS);
                   /* set material id */ 
   midb = 10;
   vis_EPropSetValuei (epropb,EPROP_MID,midb);
                   /* 3 by 2 rectangular beam */
   a = 6.;
   iyy = 2.;
   izz = 4.5;
   j = 4.7017;
   asy = 0.833;
   asz = 0.833;
   cw = 0.24272;
                   /* set section properties */ 
   vis_EPropSetValued (epropb,EPROP_AREA,a);
   vis_EPropSetValued (epropb,EPROP_IYY,iyy);
   vis_EPropSetValued (eprop,EPROP_IZZ,izz);
   vis_EPropSetValued (epropb,EPROP_IYZ,0.);
   vis_EPropSetValued (epropb,EPROP_J,j);
   vis_EPropSetValued (epropb,EPROP_CW,cw);
                   /* print contents of beam EProp */
   print_EProp (epropb);

                   /* delete objects */
   vis_EPropEnd (eprop);
   vis_EPropEnd (epropb);
}

/*----------------------------------------------------------------------
                      print EProp
----------------------------------------------------------------------*/
static void
print_EProp(vis_EProp *eprop)
{
   Vint i, j, k;
   Vint iparams[1];
   Vdouble dparams[4];
   Vint ntypes, *type;
   Vint nval, nloc, dtyp;
   Vchar name[64];
                   /* traverse defined element properties */ 
   vis_EPropValueTypeNum (eprop,&ntypes);
   printf("ntypes = %d\n",ntypes);
   type = (Vint*)malloc(ntypes*sizeof(Vint));
   vis_EPropValueType (eprop,&ntypes,type);

                   /* loop through types */ 
   for(i = 0; i < ntypes; i++) {
      vis_EPropValueName (eprop,type[i],name);
      printf("\n name = %s\n",name);
      vis_EPropValueParams (eprop,type[i],&nval,&nloc,&dtyp);
      printf(" nval= %d, nloc= %d\n",nval,nloc);

                   /* integer valued */ 
      if(dtyp == SYS_INTEGER) {
         printf(" Integer\n");
         vis_EPropValueInteger (eprop,type[i],iparams);
         for(j = 0; j < nval; j++) {
            printf("  value= %d\n",iparams[j]);
         }
                   /* real valued */ 
      } else {
         vis_EPropValueDouble (eprop,type[i],dparams);
         printf(" Real\n");
         for(k = 0; k < nloc; k++) {
            printf(" Location= %d\n",k);
            for(j = 0; j < nval; j++) {
               printf("  value= %e\n",dparams[k*nval+j]);
            }
         }
      }
   }
   free(type);
   return;
}

Table of Contents

25.32 Example 35, Manage Material Properties Using MProp

This example illustrates the use of a MProp object to manage material properties for a linear orthotropic material. Both elastic and thermal properties are input. The real valued properties are defined and queried in double precision. The number and type of properties defined are first queried using vis_MPropValueType. A loop over the defined types is entered and the name and parameters for each type are queried and printed. The property values are queried using vis_MPropValueInteger and vis_MPropValueDouble.

#include "base/base.h"
#include "vis/vis.h"

/*----------------------------------------------------------------------
                      Manage Material Properties Using MProp
----------------------------------------------------------------------*/
int
main()
{
   Vint i, j;
   Vint iparams[1];
   Vdouble dparams[3];
   vis_MProp *mprop;
   Vdouble eort[3], nuort[3], gort[3], kort[3];
   Vint ntypes, *type;
   Vint nval, dtyp;
   Vchar name[64];

                   /* create mprop for linear orthotropic properties */ 
   mprop = vis_MPropBegin ();
   vis_MPropDef (mprop,SYS_MAT_ORTHOTROPIC);

                   /* set material density */
   vis_MPropSetValued (mprop,MPROP_DENSITY,7800.);

                   /* install elastic moduli */ 
   eort[0] = 2.1e+11;
   eort[1] = 1.1e+11;
   eort[2] = 1.2e+11;
   vis_MPropSetValuedv (mprop,MPROP_EORT,eort);
   nuort[0] = .3;
   nuort[1] = .3;
   nuort[2] = .3;
   vis_MPropSetValuedv (mprop,MPROP_NUORT,nuort);
   gort[0] = .4e+11;
   gort[1] = .3e+11;
   gort[2] = .3e+11;
   vis_MPropSetValuedv (mprop,MPROP_GORT,gort);

                   /* thermal conductivity and specific heat */ 
   kort[0] = 55.;
   kort[1] = 30.;
   kort[2] = 25.;
   vis_MPropSetValuedv (mprop,MPROP_KORT,kort);
   vis_MPropSetValued (mprop,MPROP_CP,465.);

                   /* traverse defined material properties */ 
   vis_MPropValueTypeNum (mprop,&ntypes);
   printf("ntypes = %d\n",ntypes);
   type = (Vint*)malloc(ntypes*sizeof(Vint));
   vis_MPropValueType (mprop,&ntypes,type);

                   /* loop through types */ 
   for(i = 0; i < ntypes; i++) {
      vis_MPropValueName (mprop,type[i],name);
      printf("\n name = %s\n",name);
      vis_MPropValueParams (mprop,type[i],&nval,&dtyp);
      printf(" nval= %d\n",nval);

                   /* integer valued */ 
      if(dtyp == SYS_INTEGER) {
         printf(" Integer\n");
         vis_MPropValueInteger (mprop,type[i],iparams);
         for(j = 0; j < nval; j++) {
            printf("  value= %d\n",iparams[j]);
         }
                   /* real valued */ 
      } else {
         vis_MPropValueDouble (mprop,type[i],dparams);
         printf(" Real\n");
         for(j = 0; j < nval; j++) {
            printf("  value= %e\n",dparams[j]);
         }
      }
   }
                   /* end objects */ 
   free(type);
   vis_MPropEnd (mprop);
   return 0;
}

Table of Contents

25.33 Example 36, Manage Solution Properties Using SProp

This example illustrates the use of a SProp object to manage solution properties for a buckling analysis. The number of buckling modes required, the restraint case identifier and loading information are required. The initial preload is defined to be the superposition of two load cases, load cases 2 and 4, with load factors 10. and 20. respectively. The number of load cases defined using vis_SPropSetValuei with SPROP_LCASE_NUM determines the number of load case identifiers and associated load factors are input using vis_SPropSetValueiv and vis_SPropSetValuedv. A title and subtitle are defined using vis_SPropSetValuec. The real valued properties are defined and queried in double precision. The number and type of properties defined are first queried using vis_SPropValueType. A loop over the defined types is entered and the name and parameters for each type are queried and printed. The property values are queried using vis_SPropValueInteger, vis_SPropValueDouble and vis_SPropValueString.

#include "base/base.h"
#include "vis/vis.h"

/*----------------------------------------------------------------------
                      Manage Solution Properties Using SProp
----------------------------------------------------------------------*/
int
main()
{
   Vint i, j;
   Vint iparams[2];
   Vdouble dparams[6];
   Vchar cparams[81];
   vis_SProp *sprop;
   Vint ntypes, *type;
   Vint nval, dtyp;
   Vint flag, usernum;
   Vchar name[256];
   Vint dimen, dimes[2];

                   /* create sprop for buckling solution */ 
   sprop = vis_SPropBegin ();
   vis_SPropDef (sprop,SYS_SOL_BUCKLING);

                   /* set number of modes */
   vis_SPropSetValuei (sprop,SPROP_EIGEN_NUM,1);

                   /* set restraint case number */
   vis_SPropSetValuei (sprop,SPROP_RCASE,1);

                   /* set load case numbers */
   vis_SPropSetValuei (sprop,SPROP_LCASE_NUM,2);
   iparams[0] = 2;
   iparams[1] = 4;
   vis_SPropSetValueiv (sprop,SPROP_LCASE,iparams);
   dparams[0] = 10.;
   dparams[1] = 20.;
   vis_SPropSetValuedv (sprop,SPROP_LCASE_FACTOR,dparams);

                   /* set results to be saved */
   vis_SPropSetValuei (sprop,SPROP_RESFILE_NUM,1);
   vis_SPropSetValuei (sprop,SPROP_RESFILE,SYS_RES_D);

                   /* set titles */ 
   vis_SPropSetValuec (sprop,SPROP_TITLE,"Buckling solution");
   vis_SPropSetValuec (sprop,SPROP_SUBTITLE,"Example");

                   /* set a couple of user properties */ 
   vis_SPropSetValuei (sprop,SPROP_USER_NUM,2);

                   /* set "user scalar" to scalar integer value 6 */ 
   vis_SPropSetValuei (sprop,SPROP_USERDIMENUM+0,1);
   vis_SPropSetValuei (sprop,SPROP_USERDIME+0,1);
   vis_SPropSetValuec (sprop,SPROP_USERNAME+0,"user scalar");
   vis_SPropSetValuei (sprop,SPROP_USERDATATYPE+0,SYS_INTEGER);
   vis_SPropSetValuei (sprop,SPROP_USERDATA+0,6);

                   /* set "user 1" to 2x3 array of real values */ 
   vis_SPropSetValuei (sprop,SPROP_USERDIMENUM+1,2);
   dimes[0] = 3;
   dimes[1] = 2;
   vis_SPropSetValueiv (sprop,SPROP_USERDIME+1,dimes);
   vis_SPropSetValuec (sprop,SPROP_USERNAME+1,"user 2x3 array ");
   vis_SPropSetValuei (sprop,SPROP_USERDATATYPE+1,SYS_REAL);
   dparams[0] = 1.;
   dparams[1] = 2.;
   dparams[2] = 3.;
   dparams[3] = 4.;
   dparams[4] = 5.;
   dparams[5] = 6.;
   vis_SPropSetValuedv (sprop,SPROP_USERDATA+1,dparams);

                   /* traverse defined solution properties */ 
                   /* query for number of types and allocate array */ 
   vis_SPropValueTypeNum (sprop,&ntypes);
   printf("ntypes = %d\n",ntypes);
   type = (Vint*)malloc(ntypes*sizeof(Vint));
                   /* query for types */
   vis_SPropValueType (sprop,&ntypes,type);
                   /* loop through types generically */ 
   for(i = 0; i < ntypes; i++) {
      vis_SPropValueName (sprop,type[i],name);
      printf("\n name = %s\n",name);
      vis_SPropValueParams (sprop,type[i],&nval,&dtyp);
      printf(" nval= %d\n",nval);

                   /* integer valued */ 
      if(dtyp == SYS_INTEGER) {
         printf(" Integer\n");
         vis_SPropValueInteger (sprop,type[i],iparams);
         for(j = 0; j < nval; j++) {
            printf("  value= %d\n",iparams[j]);
         }
                   /* real valued */ 
      } else if(dtyp == SYS_REAL) {
         vis_SPropValueDouble (sprop,type[i],dparams);
         printf(" Real\n");
         for(j = 0; j < nval; j++) {
            printf("  value= %e\n",dparams[j]);
         }
                   /* character valued */ 
      } else if(dtyp == SYS_CHAR) {
         vis_SPropValueString (sprop,type[i],cparams);
         printf("  value= %s\n",cparams);
      }
   }
   free(type);
                   /* specifically access user data */
   printf("\nUser data\n");
   usernum = 0;
   vis_SPropValueFlag (sprop,SPROP_USER_NUM,&flag);
   if(flag) {
      vis_SPropValueInteger (sprop,SPROP_USER_NUM,&usernum);
   }
   for(i = 0; i < usernum; i++) {
      vis_SPropValueInteger (sprop,SPROP_USERDIMENUM+i,&dimen);
      vis_SPropValueInteger (sprop,SPROP_USERDIME+i,dimes);
      vis_SPropValueString (sprop,SPROP_USERNAME+i,name);
      vis_SPropValueInteger (sprop,SPROP_USERDATATYPE+i,&dtyp);
      printf("\n");
      printf("name= %s\n",name);
      printf("number of dimensions= %d\n",dimen);
      printf("dimensions=");
      nval = 1;
      for(j = 0; j < dimen; j++) {
         printf(" %d",dimes[j]);
         nval *= dimes[j];
      }
      printf("\n");
      printf("datatype= %d\n",dtyp);
                   /* integer valued */
      if(dtyp == SYS_INTEGER) {
         printf(" Integer\n");
         vis_SPropValueInteger (sprop,SPROP_USERDATA+i,iparams);
         for(j = 0; j < nval; j++) {
            printf("  value= %d\n",iparams[j]);
         }
                   /* real valued */
      } else if(dtyp == SYS_REAL) {
         vis_SPropValueDouble (sprop,SPROP_USERDATA+i,dparams);
         printf(" Real\n");
         for(j = 0; j < nval; j++) {
            printf("  value= %e\n",dparams[j]);
         }
                   /* character valued */
      } else if(dtyp == SYS_CHAR) {
         vis_SPropValueString (sprop,SPROP_USERDATA+i,cparams);
         printf("  value= %s\n",cparams);
      }
   }
                   /* end objects */ 
   vis_SPropEnd (sprop);
   return 0;
}

Table of Contents

25.34 Example 37, Manage Tabular Functions Using TCurve

This example illustrates the use of a TCurve object to manage tables of temperature dependent material data. Two TCurve objects are instanced, one to store the temperature dependent values of elastic modulus and Poisson's ratio, and a second to store the temperature dependent values of density. The material data for the two curves is entered as piecewise linear functions using vis_TCurveSetPWLineardv. A third function object is instanced and defined as a piece wise linear function which is generated as a combination of the first two functions. The result is a vector valued function of dimension 3 which holds elastic modulus, Poisson's ratio and density at a common set of temperature values.

#include "base/base.h"
#include "vis/vis.h"

/*----------------------------------------------------------------------
                      Manage Tabular Functions Using TCurve
----------------------------------------------------------------------*/
int
main()
{
   Vint i;
   vis_TCurve *tcurve1, *tcurve2, *tcurve;
   vis_TCurve *tc[2];
   Vdouble temp[5];
   Vdouble elas[4][2], dens[5];
   Vdouble t, f[3];
   Vint npts;

                   /* create tcurve for temperature dependent E, Nu, data */ 
   tcurve1 = vis_TCurveBegin ();
   vis_TCurveDef (tcurve1,TCURVE_PWLINEAR,2);

                   /* set data */
   temp[0] =  20.;
   temp[1] = 100.;
   temp[2] = 150.;
   temp[3] = 180.;
   elas[0][0] = 12000000.;  elas[0][1] = .30;
   elas[1][0] = 11000000.;  elas[1][1] = .31;
   elas[2][0] = 10000000.;  elas[2][1] = .33;
   elas[3][0] =  9000000.;  elas[3][1] = .35;
   vis_TCurveSetPWLineardv (tcurve1,4,temp,(Vdouble*)elas);

   for(i = 0; i <= 10; i++) {
      t = 20.*i;
      vis_TCurveEvaldv (tcurve1,1,&t,f);
      printf("t= %f: E= %f,  Nu= %f\n",t,f[0],f[1]);
   }

                   /* create curve for density */ 
   tcurve2 = vis_TCurveBegin ();
   vis_TCurveDef (tcurve2,TCURVE_PWLINEAR,1);

                   /* set data */ 
   temp[0] =   0.;
   temp[1] =  80.;
   temp[2] = 120.;
   temp[3] = 150.;
   temp[4] = 200.;
   dens[0] = 1.0e-4;
   dens[1] = 1.2e-4;
   dens[2] = 1.3e-4;
   dens[3] = 1.4e-4;
   dens[4] = 1.5e-4;
   vis_TCurveSetPWLineardv (tcurve2,5,temp,dens);

                   /* merge curves */ 
   tcurve = vis_TCurveBegin ();
   vis_TCurveDef (tcurve,TCURVE_PWLINEAR,3);
   tc[0] = tcurve1;
   tc[1] = tcurve2;
   vis_TCurveMerge (tcurve,2,tc);

                   /* query for merged independent points */ 
   vis_TCurveNum (tcurve,&npts);
   printf("npts= %d\n",npts);
   for(i = 1; i <= npts; i++) {
      vis_TCurveIndepdv (tcurve,1,&i,&t);
      printf("pt= %d, t= %f\n",i,t);
   }

                   /* evaluate at equally spaced intervals */ 
   for(i = 0; i <= 10; i++) {
      t = 20.*i;
      vis_TCurveEvaldv (tcurve,1,&t,f);
      printf("t= %f: E= %f,  Nu= %f,  rho= %f\n",t,f[0],f[1],f[2]);
   }
   
                   /* end objects */ 
   vis_TCurveEnd (tcurve1);
   vis_TCurveEnd (tcurve2);
   vis_TCurveEnd (tcurve);
   return 0;
}

Table of Contents

25.35 Example 38, Manage Results Properties Using RProp

This example illustrates the use of an RProp object to manage results properties for element stress for a shell section. Optional qualifiers for Equivalent Plastic stress are specified using vis_RPropSetQual. The numeric identifier 1 and 2 are specified using vis_RPropSetIds. These identifiers could be interpreted, for example, as solution sequence 1, time step 2. The function vis_RPropGetDatasetName can be used to query for the equivalent dataset name.

A title and subtitle are defined using vis_RPropSetValuec. The real valued properties are defined and queried in double precision. The number and type of properties defined are first queried using vis_RPropValueType. A loop over the defined types is entered and the name and parameters for each type are queried and printed. The property values are queried using vis_RPropValueInteger, vis_RPropValueDouble and vis_RPropValueString.

Conversely, a dataset name can be specified using vis_RPropSetDatasetName and the equivalent component values are queried.

#include "base/base.h"
#include "vis/vis.h"

/*----------------------------------------------------------------------
                      Manage Result Properties Using RProp
----------------------------------------------------------------------*/
int
main()
{
   Vint i, j;
   Vint type, id1, id2, id3;
   Vint iparams[2];
   Vdouble dparams[2];
   Vchar cparams[81];
   vis_RProp *rprop;
   Vint ntypes, types[RPROP_MAX];
   Vint nval, dtyp;
   Vchar name[64];
   Vint nqua, iqua[SYS_NQUA_MAX];
   Vchar cqua[64];

                   /* create rprop for stress results */ 
   rprop = vis_RPropBegin ();
   vis_RPropDef (rprop,SYS_ELEM,SYS_NONE);

                   /* set type */ 
   vis_RPropSetType (rprop,SYS_RES_S);

                   /* set optional qualifier(s) */ 
   iqua[0] = SYS_QUA_EQUIV;
   iqua[1] = SYS_QUA_PLAST;
   vis_RPropSetQual (rprop,2,iqua,NULL);

                   /* set ids */ 
   vis_RPropSetIds (rprop,1,2,0);

                   /* query primary properties */ 
   vis_RPropGetType (rprop,&type);
   vis_RPropGetQual (rprop,&nqua,iqua,cqua);
   vis_RPropGetIds (rprop,&id1,&id2,&id3);
   printf("type = %d\n",type);
   printf("nqua = %d\n",nqua);
   for(i = 0; i < nqua; i++) {
      printf("iqua[%d] = %d\n",i,iqua[i]);
   }
   printf("cqua = %s\n",cqua);
   printf("id1,id2,id3 = %d %d %d\n",id1,id2,id3);

                   /* query equivalent dataset name */ 
   vis_RPropGetDatasetName (rprop,name);
   printf("dataset name = %s\n",name);

                   /* set titles */
   vis_RPropSetValuec (rprop,RPROP_TITLE,"Drop test case");
   vis_RPropSetValuec (rprop,RPROP_SUBTITLE,"Oblique strike");

                   /* set load factor */ 
   vis_RPropSetValued (rprop,RPROP_LOADFACTOR,1.);

                   /* traverse defined solution properties */ 
   vis_RPropValueType (rprop,&ntypes,types);
   printf("\n ntypes = %d\n",ntypes);

                   /* loop through types */ 
   for(i = 0; i < ntypes; i++) {
      vis_RPropValueName (rprop,types[i],name);
      printf("\n name = %s\n",name);
      vis_RPropValueParams (rprop,types[i],&nval,&dtyp);
      printf(" nval= %d\n",nval);

                   /* integer valued */ 
      if(dtyp == SYS_INTEGER) {
         printf(" Integer\n");
         vis_RPropValueInteger (rprop,types[i],iparams);
         for(j = 0; j < nval; j++) {
            printf("  value= %d\n",iparams[j]);
         }
                   /* real valued */ 
      } else if(dtyp == SYS_REAL) {
         vis_RPropValueDouble (rprop,types[i],dparams);
         printf(" Real\n");
         for(j = 0; j < nval; j++) {
            printf("  value= %e\n",dparams[j]);
         }
                   /* character valued */ 
      } else if(dtyp == SYS_CHAR) {
         vis_RPropValueString (rprop,types[i],cparams);
         printf("  value= %s\n",cparams);
      }
   }
                   /* now conversely, set dataset name */ 
   vis_RPropSetDatasetName (rprop,"D.N:1");
                   /* query for equivalent primary properties */
   vis_RPropGetType (rprop,&type);
   vis_RPropGetQual (rprop,&nqua,iqua,cqua);
   vis_RPropGetIds (rprop,&id1,&id2,&id3);
   printf("type = %d\n",type);
   printf("nqua = %d\n",nqua);
   for(i = 0; i < nqua; i++) {
      printf("iqua[%d] = %d\n",i,iqua[i]);
   }
   printf("cqua = %s\n",cqua);
   printf("id1,id2,id3 = %d %d %d\n",id1,id2,id3);

                   /* end objects */ 
   vis_RPropEnd (rprop);
   return 0;
}

Table of Contents

25.36 Example 38avdm, Export Simple Finite Element Model and Results

This example uses the same finite element model introduced in Example 23 and illustrates the use of the Model and State objects to export a finite element model with displacement and stress results to SDRC Universal file file format. It then illustrates using VdmTools objects to export to NASTRAN OUTPUT2 file format.

Initially, the finite element model is loaded into a Connect object. A Model object is instanced and the Connect object is installed in it using vis_ModelSetObject. The function vis_ModelWrite is then called to write the model information to a SDRC Universal file. The amount of information written depends upon the types of objects installed in Model. In this example only basic element type and connectivity and node coordinates are be written.

In order to illustrate exporting a node vector and element node tensor, the node coordinate data is used for convenience as the data source for the components of a node displacement vector and the direct stress components of an element node stress tensor. A GridFun object must be created to be used by the State object whenever the State object data is exported. A node State object is instanced and filled with the node coordinate data. In order to export the State data an associated RProp object must be used to describe the global properties of the results quantity. In this example the function vis_RPropSetType is used to set the basic result type, vis_RPropSetIds is used to define a case identifier and vis_RPropSetValuec is used to specify a title. The function vis_StateWrite is called to write the node displacement vector to a SDRC Universal file. Note that if an existing file is used when exporting to SDRC Universal file format, the data will be appended to the existing file. SDRC Universal file format supports model and result quantities in a single file. An element node State object is then instanced and filled with the node coordinate data for the direct stress components and zeroes for the shear stress components. An associated RProp object is created and the stress results are written using vis_StateWrite.

Finally, the Model and State objects are exported to a NASTRAN .op2 file using VdmTools modules. A DataFun and LMan object are required to do the exporting. For each file type to be exported to the appropriate interface object must be used, ie NASLib for NASTRAN. The function vdm_LManSaveModel exports the model information and vdm_LManSaveState exports the results data.

#include <stdio.h>
#include "base/base.h"
#include "vis/visdata.h"
#include "vdm/vdm.h"
/*
                 6------7
                /.     /.\
  y            / .    / . \
  |           /  .   /  .  \8------9
  --x        /   1../...2../|      | \
 /         13-----14-----15 |      |  \
z           |  .   |  .   |.|      |   \
            | .    | .    | 3------4-----5
            |.     |.     |/
           10-----11-----12
*/
#define MAX_ELEM  4
#define MAX_NODE 15

static Vint conn[MAX_ELEM][8] = {
   {1, 2, 7, 6,10,11,14,13},
   {2, 3, 8, 7,11,12,15,14},
   {3, 4, 9, 8, 0, 0, 0, 0},
   {4, 5, 9, 0, 0, 0, 0, 0} };

static Vint shap[MAX_ELEM] = {
   VIS_SHAPEHEX, VIS_SHAPEHEX, VIS_SHAPEQUAD, VIS_SHAPETRI };

static Vint etyp[MAX_ELEM] = {
   VIS_ELEM_SOLID, VIS_ELEM_SOLID, VIS_ELEM_SHELL, VIS_ELEM_SHELL };

static Vfloat coords[MAX_NODE][3] = {
   {0.,0.,0.},  {1.,0.,0.},  {2.,0.,1.},  {3.,0.,1.},  {4.,0.,1.},
   {0.,1.,0.},  {1.,1.,0.},  {2.,1.,1.},  {3.,1.,1.}, 
   {0.,0.,2.},  {1.,0.,2.},  {2.,0.,2.},
   {0.,1.,2.},  {1.,1.,2.},  {2.,1.,2.} };

/*----------------------------------------------------------------------
                      Export Simple Finite Element Model and Results
----------------------------------------------------------------------*/
int
main()
{
   Vint i, j, k;
   vis_Connect *connect;
   vis_Model *model;
   vis_State *staten, *stateen;
   vis_RProp *rpropn, *rpropen;
   vis_GridFun *gf;
   Vint nix, ix[8], nsec;
   Vfloat enstress[8][6];

   vdm_LMan *lman;
   vdm_DataFun *datafun;
   vdm_NASLib *naslib;
   vdm_SDRCLib *sdrclib;
   vdm_CGNSVLib *cgnsvlib;

                   /* create connect object */
   connect = vis_ConnectBegin ();
   vis_ConnectDef (connect,MAX_NODE,MAX_ELEM);

                   /* set topology and connectivity */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetTopology (connect,i+1,shap[i],2,0,0);
      vis_ConnectSetElemNode (connect,i+1,conn[i]);
      vis_ConnectSetElemAssoc (connect,VIS_FEATYPE,i+1,etyp[i]);
   }
                   /* set node coordinates */ 
   for(i = 0; i < MAX_NODE; i++) {
      vis_ConnectSetCoords (connect,i+1,coords[i]);
   }

                   /* create model object and install connect object */ 
   model = vis_ModelBegin();
   vis_ModelSetObject (model,VIS_CONNECT,connect);

                   /* write model data */ 
   vis_ModelWrite (model,SYS_SDRC_UNIVERSAL,"exam38avdm.unv1");

                   /* create a grid function object */
   gf = vis_GridFunBegin ();
   vis_ConnectGridFun (connect,gf);

                   /* create a node vector state */ 
   staten = vis_StateBegin();
   vis_StateDef (staten,MAX_NODE,SYS_NODE,SYS_NONE,VIS_VECTOR);
   vis_StateSetObject (staten,VIS_GRIDFUN,gf);

                   /* use node coordinates as "displacements" for convenience */
   for(i = 0; i < MAX_NODE; i++) {
      vis_StateSetData (staten,i+1,coords[i]);
   }
                   /* create result property for node state */ 
   rpropn = vis_RPropBegin();
   vis_RPropDef (rpropn,SYS_NODE,SYS_NONE);
                   /* set displacement quantity */ 
   vis_RPropSetType (rpropn,SYS_RES_D);
                   /* set ids, eg. step 1, increment 1 */
   vis_RPropSetIds (rpropn,1,1,0);
   vis_RPropSetValued (rpropn,RPROP_TIME,1.);
   vis_RPropSetValuec (rpropn,RPROP_TITLE,"Displacements under load case 1");

                   /* write node state data */ 
                   /* SDRC, previous file can be appended to */
   vis_StateWrite (staten,rpropn,SYS_SDRC_UNIVERSAL,"exam38avdm.unv1");

                   /* create an element node state */
   stateen = vis_StateBegin();
   vis_StateDef (stateen,MAX_ELEM,SYS_ELEM,SYS_NODE,VIS_TENSOR);
   vis_StateSetObject (stateen,VIS_GRIDFUN,gf);

                   /* set number of sections for solids and shells */
   for(i = 0; i < MAX_ELEM; i++) {
      if(etyp[i] == VIS_ELEM_SOLID) {
         nsec = 1;
      } else if(etyp[i] == VIS_ELEM_SHELL) {
         nsec = 2;
      }
      vis_StateSetDataSect (stateen,i+1,nsec);
   }
                   /* use node coordinates as "stress" for convenience */
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectElemNode (connect,i+1,&nix,ix);
                   /* gather */ 
      if(etyp[i] == VIS_ELEM_SOLID) {
         for(j = 0; j < nix; j++) {
            enstress[j][0] = coords[ix[j]-1][0];
            enstress[j][1] = coords[ix[j]-1][1];
            enstress[j][2] = coords[ix[j]-1][2];
            enstress[j][3] = 0.;
            enstress[j][4] = 0.;
            enstress[j][5] = 0.;
         }
                   /* double coordinates for second section for shells */ 
      } else if(etyp[i] == VIS_ELEM_SHELL) {
         for(k = 0; k < 2; k++) {
            for(j = 0; j < nix; j++) {
               enstress[k*nix+j][0] = (k+1)*coords[ix[j]-1][0];
               enstress[k*nix+j][1] = (k+1)*coords[ix[j]-1][1];
               enstress[k*nix+j][2] = 0.;
               enstress[k*nix+j][3] = (k+1)*coords[ix[j]-1][2];
               enstress[k*nix+j][4] = 0.;
               enstress[k*nix+j][5] = 0.;
            }
         }
      }
      vis_StateSetData (stateen,i+1,(Vfloat*)enstress);
   }
                   /* create result property for element node state */
   rpropen = vis_RPropBegin();
   vis_RPropDef (rpropen,SYS_ELEM,SYS_NODE);
                   /* set stress quantity */
   vis_RPropSetType (rpropen,SYS_RES_S);
                   /* set ids, eg. step 1, increment 1 */
   vis_RPropSetIds (rpropen,1,1,0);
   vis_RPropSetValued (rpropen,RPROP_TIME,1.);
                   /* set name of section dataset */ 
   vis_RPropSetValuec (rpropen,RPROP_LINK_SECTION,"ELEM.SECT.E:1");
   vis_RPropSetValuec (rpropen,RPROP_TITLE,"Stress under load case 1");

                   /* write element node state data */
                   /* SDRC, previous file can be appended to */
   vis_StateWrite (stateen,rpropen,SYS_SDRC_UNIVERSAL,"exam38avdm.unv1");

                   /* now export to VdmTools supported results files */ 
   datafun = vdm_DataFunBegin();
   lman = vdm_LManBegin();
   vdm_LManSetObject (lman,VDM_DATAFUN,datafun);

                   /* write to NASTRAN .op2 */ 
   naslib = vdm_NASLibBegin();
   vdm_NASLibDataFun (naslib,datafun);
   vdm_DataFunSetStatus (datafun,VDM_STATUS_NEW);
   vdm_DataFunOpen (datafun,0,"exam38avdm.op2",SYS_NASTRAN_OUTPUT2);
   vdm_LManSaveModel (lman,model);
   vdm_LManSaveState (lman,staten,rpropn);
   vdm_LManSaveState (lman,stateen,rpropen);
   vdm_DataFunClose (datafun);
   vdm_NASLibEnd (naslib);

                   /* write to SDRC .unv */ 
   sdrclib = vdm_SDRCLibBegin();
   vdm_SDRCLibDataFun (sdrclib,datafun);
   vdm_DataFunSetStatus (datafun,VDM_STATUS_NEW);
   vdm_DataFunOpen (datafun,0,"exam38avdm.unv",SYS_SDRC_UNIVERSAL);
   vdm_LManSaveModel (lman,model);
   vdm_LManSaveState (lman,staten,rpropn);
   vdm_LManSaveState (lman,stateen,rpropen);
   vdm_DataFunClose (datafun);
   vdm_SDRCLibEnd (sdrclib);

                   /* write to CGNS .cgns */
   cgnsvlib = vdm_CGNSVLibBegin();
   vdm_CGNSVLibDataFun (cgnsvlib,datafun);
   vdm_DataFunSetStatus (datafun,VDM_STATUS_NEW);
   vdm_DataFunOpen (datafun,0,"exam38avdm.cgns",SYS_CGNS);
   if(vdm_DataFunError(datafun) == 0) {
      vdm_LManSaveModel (lman,model);
      vdm_LManSaveState (lman,staten,rpropn);
      vdm_LManSaveState (lman,stateen,rpropen);
      vdm_DataFunClose (datafun);
   }
   vdm_CGNSVLibEnd (cgnsvlib);

                   /* end objects */ 
   vis_ModelEnd (model);
   vis_ConnectEnd (connect);
   vis_StateEnd (staten);
   vis_RPropEnd (rpropn);
   vis_StateEnd (stateen);
   vis_RPropEnd (rpropen);
   vis_GridFunEnd (gf);
 
   vdm_DataFunEnd (datafun);
   vdm_LManEnd (lman);
   return 0;
}

Table of Contents

25.37 Example 38bvdm, Export Simple CFD Finite Element Model and Results

This example illustrates the use of the Model and State objects to export a CFD style finite element model with node velocity results and element pressure results to SDRC Universal file, CGNS file, Fluent .msh file and EnSight .case file format.

Initially, the finite element model is loaded into a Connect object. A Model object is instanced and the Connect object is installed in it using vis_ModelSetObject. The finite element model consists of some features characteristic of CFD models. The external faces of the volume elements are explicitly represented by interface elements. The interface elements are used to specify boundary conditions of some type, in this case "wall", "outlet" and "inlet". These types are reflected in the VIS_FEASPEC element association. Another feature is the assignment of a "zone" to the volume and interface elements. In this case the VIS_PROPID (appropriate for structural analysis related file formats) and VIS_PARTID (appropriate for CFD related file formats) element associations are used to assign a zone identifier.

An optional, user defined name is specified for the interface element associated with the outlet. Note that elements in different zones should not be given the same name. This name will be exported if the target file format supports user defined names.

A node velocity state is generated in a manner similar to Example 38avdm. An element scalar pressure state is generated. The Model and two State objects are exported using VdmTools modules.

#include <stdio.h>
#include "base/base.h"
#include "vis/visdata.h"
#include "vdm/vdm.h"
/*
  y            4------5------6
  |           /.     /.     /|
  --x        / .    / .    / |
 /         10-----11-----12  |
z           |  1...|..2...|..3
            | .    | .    | /
            |.     |.     |/
            7------8------9
*/
#define MAX_ELEM 12
#define MAX_NODE 12

static Vint conn[MAX_ELEM][8] = {
 { 1, 2, 5, 4, 7, 8,11,10}, { 2, 3, 6, 5, 8, 9,12,11},
 { 1, 4, 5, 2, 0, 0, 0, 0}, { 2, 5, 6, 3, 0, 0, 0, 0},
 { 4,10,11, 5, 0, 0, 0, 0}, { 5,11,12, 6, 0, 0, 0, 0},
 {10, 7, 8,11, 0, 0, 0, 0}, {11, 8, 9,12, 0, 0, 0, 0},
 { 7, 1, 2, 8, 0, 0, 0, 0}, { 8, 2, 3, 9, 0, 0, 0, 0},
 { 3, 6,12, 9, 0, 0, 0, 0}, { 1, 4,10, 7, 0, 0, 0, 0} };

static Vint shap[MAX_ELEM] = {
   SYS_SHAPEHEX,  SYS_SHAPEHEX,
   SYS_SHAPEQUAD, SYS_SHAPEQUAD,
   SYS_SHAPEQUAD, SYS_SHAPEQUAD,
   SYS_SHAPEQUAD, SYS_SHAPEQUAD,
   SYS_SHAPEQUAD, SYS_SHAPEQUAD,
   SYS_SHAPEQUAD, SYS_SHAPEQUAD };

static Vint etyp[MAX_ELEM] = {
   VIS_ELEM_SOLID, VIS_ELEM_SOLID,
   VIS_ELEM_INTER, VIS_ELEM_INTER,
   VIS_ELEM_INTER, VIS_ELEM_INTER,
   VIS_ELEM_INTER, VIS_ELEM_INTER,
   VIS_ELEM_INTER, VIS_ELEM_INTER,
   VIS_ELEM_INTER, VIS_ELEM_INTER };

static Vint espc[MAX_ELEM] = {
   SYS_SOLID_FLUID,  SYS_SOLID_FLUID,
   SYS_INTER_WALL,   SYS_INTER_WALL,
   SYS_INTER_WALL,   SYS_INTER_WALL,
   SYS_INTER_WALL,   SYS_INTER_WALL,
   SYS_INTER_WALL,   SYS_INTER_WALL,
   SYS_INTER_OUTLET, SYS_INTER_INLET };

static Vint prop[MAX_ELEM] = {
   1, 1,
   2, 2,
   3, 3,
   4, 4,
   5, 5,
   6, 7 };

static Vfloat coords[MAX_NODE][3] = {
   {0.,0.,0.},  {1.,0.,0.},  {2.,0.,0.},
   {0.,1.,0.},  {1.,1.,0.},  {2.,1.,0.},
   {0.,0.,2.},  {1.,0.,2.},  {2.,0.,2.},
   {0.,1.,2.},  {1.,1.,2.},  {2.,1.,2.} };

/*----------------------------------------------------------------------
                      Export Simple CFD Finite Element Model and Results
----------------------------------------------------------------------*/
int
main()
{
   Vint i;
   vis_Connect *connect;
   vis_Model *model;
   vis_State *staten, *statee, *stateg;
   vis_RProp *rpropn, *rprope, *rpropg;
   vis_GridFun *gf;

   vdm_LMan *lman;
   vdm_DataFun *datafun;
   vdm_SDRCLib *sdrclib;
   vdm_CGNSVLib *cgnsvlib;
   vdm_FLUENTLib *fluentlib;
   vdm_EnSightLib *ensightlib;
   vdm_TecplotLib *tecplotlib;
   vdm_NatLib *natlib;

                   /* create connect object */
   connect = vis_ConnectBegin ();
   vis_ConnectDef (connect,MAX_NODE,MAX_ELEM);

                   /* set topology and connectivity */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetTopology (connect,i+1,shap[i],2,0,0);
      vis_ConnectSetElemNode (connect,i+1,conn[i]);
      vis_ConnectSetElemAssoc (connect,VIS_FEATYPE,i+1,etyp[i]);
      vis_ConnectSetElemAssoc (connect,VIS_FEASPEC,i+1,espc[i]);
      vis_ConnectSetElemAssoc (connect,VIS_PROPID,i+1,prop[i]);
      vis_ConnectSetElemAssoc (connect,VIS_PARTID,i+1,prop[i]);
      if(espc[i] == SYS_INTER_OUTLET) {
         vis_ConnectSetPartName (connect,prop[i],"outlet");
      }
   }
                   /* set node coordinates */ 
   for(i = 0; i < MAX_NODE; i++) {
      vis_ConnectSetCoords (connect,i+1,coords[i]);
   }
                   /* create model object and install connect object */ 
   model = vis_ModelBegin();
   vis_ModelSetObject (model,VIS_CONNECT,connect);

                   /* create a grid function object */
   gf = vis_GridFunBegin ();
   vis_ConnectGridFun (connect,gf);

                   /* create a node vector state */ 
   staten = vis_StateBegin();
   vis_StateDef (staten,MAX_NODE,SYS_NODE,SYS_NONE,VIS_VECTOR);
   vis_StateSetObject (staten,VIS_GRIDFUN,gf);

                   /* use node coordinates as "velocity" for convenience */
   for(i = 0; i < MAX_NODE; i++) {
      vis_StateSetData (staten,i+1,coords[i]);
   }
                   /* create result property for node velocity state */ 
   rpropn = vis_RPropBegin();
   vis_RPropDef (rpropn,SYS_NODE,SYS_NONE);
                   /* set velocity quantity */ 
   vis_RPropSetType (rpropn,SYS_RES_V);
                   /* set ids, eg. step 1 */
   vis_RPropSetIds (rpropn,1,0,0);
   vis_RPropSetValuec (rpropn,RPROP_TITLE,"Velocity step 1");

                   /* create a element scalar pressure state */ 
   statee = vis_StateBegin();
   vis_StateDef (statee,MAX_ELEM,SYS_ELEM,SYS_NONE,VIS_SCALAR);
   vis_StateSetObject (statee,VIS_GRIDFUN,gf);
                   /* use element number as "pressure" for convenience */
   for(i = 0; i < MAX_ELEM; i++) {
      Vfloat s;
      s = i+1;
      vis_StateSetData (statee,i+1,&s);
   }
                   /* create result property for element pressure state */ 
   rprope = vis_RPropBegin();
   vis_RPropDef (rprope,SYS_ELEM,SYS_NONE);
   vis_RPropSetType (rprope,SYS_RES_PRES);
   vis_RPropSetIds (rprope,1,0,0);
   vis_RPropSetValuec (rprope,RPROP_TITLE,"Pressure step 1");

                   /* create a element scalar generic state */
   stateg = vis_StateBegin();
   vis_StateDef (stateg,MAX_ELEM,SYS_ELEM,SYS_NONE,VIS_SCALAR);
   vis_StateSetObject (stateg,VIS_GRIDFUN,gf);
                   /* use negative element number as data for convenience */
   for(i = 0; i < MAX_ELEM; i++) {
      Vfloat s;
      s = i+1;
      vis_StateSetData (stateg,i+1,&s);
   }
                   /* create result property for element generic state */
   rpropg = vis_RPropBegin();
   vis_RPropDef (rpropg,SYS_ELEM,SYS_NONE);
   vis_RPropSetType (rpropg,SYS_RES_UNKNOWN);
   vis_RPropSetQual (rpropg,0,NULL,"MyGenericData");
   vis_RPropSetIds (rpropg,1,0,0);
   vis_RPropSetValuec (rpropg,RPROP_TITLE,"GenericData step 1");

                   /* now export to VdmTools supported results files */ 
   datafun = vdm_DataFunBegin();
   lman = vdm_LManBegin();
   vdm_LManSetObject (lman,VDM_DATAFUN,datafun);

                   /* write to SDRC .unv */ 
   sdrclib = vdm_SDRCLibBegin();
   vdm_SDRCLibDataFun (sdrclib,datafun);
   vdm_DataFunSetStatus (datafun,VDM_STATUS_NEW);
   vdm_DataFunOpen (datafun,0,"exam38bvdm.unv",SYS_SDRC_UNIVERSAL);
   vdm_LManSaveModel (lman,model);
   vdm_LManSaveState (lman,staten,rpropn);
   vdm_LManSaveState (lman,statee,rprope);
   vdm_LManSaveState (lman,stateg,rpropg);
   vdm_DataFunClose (datafun);
   vdm_SDRCLibEnd (sdrclib);

                   /* write to CGNS .cgns */
   cgnsvlib = vdm_CGNSVLibBegin();
   vdm_CGNSVLibDataFun (cgnsvlib,datafun);
   vdm_DataFunSetStatus (datafun,VDM_STATUS_NEW);
   vdm_DataFunOpen (datafun,0,"exam38bvdm.cgns",SYS_CGNS);
   if(vdm_DataFunError(datafun) == 0) {
      vdm_LManSaveModel (lman,model);
      vdm_LManSaveState (lman,staten,rpropn);
      vdm_LManSaveState (lman,statee,rprope);
      vdm_LManSaveState (lman,stateg,rpropg);
   }
   vdm_DataFunClose (datafun);
   vdm_CGNSVLibEnd (cgnsvlib);

                   /* write to FLUENT .msh */
   fluentlib = vdm_FLUENTLibBegin();
   vdm_FLUENTLibDataFun (fluentlib,datafun);
   vdm_DataFunSetStatus (datafun,VDM_STATUS_NEW);
   vdm_DataFunOpen (datafun,0,"exam38bvdm.msh",SYS_FLUENT_MESH);
   vdm_LManSaveModel (lman,model);
   vdm_LManSaveState (lman,staten,rpropn);
   vdm_LManSaveState (lman,statee,rprope);
   vdm_LManSaveState (lman,stateg,rpropg);
   vdm_DataFunClose (datafun);
   vdm_FLUENTLibEnd (fluentlib);

                   /* write to EnSight .case */ 
   ensightlib = vdm_EnSightLibBegin();
   vdm_EnSightLibDataFun (ensightlib,datafun);
   vdm_DataFunSetStatus (datafun,VDM_STATUS_NEW);
   vdm_DataFunOpen (datafun,0,"exam38bvdm.case",SYS_ENSIGHT);
   vdm_LManSaveModel (lman,model);
   vdm_LManSaveState (lman,staten,rpropn);
   vdm_LManSaveState (lman,statee,rprope);
   vdm_LManSaveState (lman,stateg,rpropg);
   vdm_DataFunClose (datafun);
   vdm_EnSightLibEnd (ensightlib);

                   /* write to Tecplot .plt */
   tecplotlib = vdm_TecplotLibBegin();
   vdm_TecplotLibDataFun (tecplotlib,datafun);
   vdm_DataFunSetStatus (datafun,VDM_STATUS_NEW);
   vdm_DataFunOpen (datafun,0,"exam38bvdm.plt",SYS_TECPLOT);
   vdm_LManSaveModel (lman,model);
   vdm_LManSaveState (lman,staten,rpropn);
   vdm_LManSaveState (lman,statee,rprope);
   vdm_LManSaveState (lman,stateg,rpropg);
   vdm_DataFunClose (datafun);
   vdm_TecplotLibEnd (tecplotlib);

                   /* write to Native .vdm */ 
   natlib = vdm_NatLibBegin();
   vdm_NatLibDataFun (natlib,datafun);
   vdm_DataFunSetStatus (datafun,VDM_STATUS_NEW);
   vdm_DataFunOpen (datafun,0,"exam38bvdm.vdm",SYS_NATIVE);
   vdm_LManSaveModel (lman,model);
   vdm_LManSaveState (lman,staten,rpropn);
   vdm_LManSaveState (lman,statee,rprope);
   vdm_LManSaveState (lman,stateg,rpropg);
   vdm_DataFunClose (datafun);
   vdm_NatLibEnd (natlib);

                   /* end objects */ 
   vis_ModelEnd (model);
   vis_ConnectEnd (connect);
   vis_StateEnd (staten);
   vis_StateEnd (statee);
   vis_StateEnd (stateg);
   vis_RPropEnd (rpropn);
   vis_RPropEnd (rprope);
   vis_RPropEnd (rpropg);
   vis_GridFunEnd (gf);
 
   vdm_DataFunEnd (datafun);
   vdm_LManEnd (lman);
   return 0;
}

Table of Contents

25.38 Example 39, Export a Simple Linear Static Solveable Model

This example illustrates the use of a Model object hierarchy to manage a simple structural analysis finite element model. The Model object acts as a container object for other VisTools and DevTools base objects which together define the finite element model. These objects are then registered in the Model object using vis_ModelSetObject, vis_ModelSetHashTable and vis_ModelSetList.

The basic finite element node coordinates, element type, connectivity and property identifiers are defined in a Connect object in the usual way. A single Connect object is registered in the Model hierarchy using vis_ModelSetObject. Element and material properties are defined using one or more EProp and MProp objects respectively. These objects are entered into HashTable objects ephash and mphash using the property identifier as a key. These HashTable objects are in turn registered in the Model hierarchy using vis_ModelSetHashTable. Restraint and load cases are defined using RCase and LCase objects respectively. Since there may generally be several restraint cases and load cases, these objects are registered in HashTable objects using the case identifiers as keys in a manner similar to element and material properties. These HashTable objects are also registered in the Model object using vis_ModelSetHashTable.

Solution properties are managed using the SProp object. It is assumed that one or more solutions are executed serially by a finite element solver. As a result the sequence of solutions are registered in a List object using the solution sequence number as a key starting from 1. In this example there is a single solution sequence SProp object which is entered into the first position of a List object. The List of solution procedures is registered with the Model object using vis_ModelSetList.

#include "base/base.h"
#include "vis/vis.h"
/*
                 4------5------6
       r        /.     /.     /.
       e       / .    / .    / .
       s      /  .   /  .   /  .
       t     /   1../...2../...3
       r    20-----21-----22  /    +--- pressure 50.
       a    |  .   |  .   |  /
       i    | .    | .    | /
       t    |.     |.     |/
            7------8------9

         y
         |
         --- x
       /
      z
*/
#define MAX_ELEM  2
#define MAX_NODE 12

                   /* element connectivity */ 
static Vint conn[MAX_ELEM][8] = {
  {1, 2, 5, 4, 7, 8,21,20},
  {2, 3, 6, 5, 8, 9,22,21} };

                   /* user element ids */ 
static Vint eid[MAX_ELEM] = {
   10,20 };
                   /* element topologies */ 
static Vint shap[MAX_ELEM] = {
   VIS_SHAPEHEX, VIS_SHAPEHEX };
static Vint maxi[MAX_ELEM] = {
   2, 2 };
                   /* element types */ 
static Vint featype[MAX_ELEM] = {
   VIS_ELEM_SOLID, VIS_ELEM_SOLID };

                   /* element property ids */ 
static Vint pid[MAX_ELEM] = {
   1, 1 };
                   /* node coordinates */ 
static Vdouble coords[MAX_NODE][3] = {
   {0.,0.,0.},  {1.,0.,0.},  {2.,0.,0.},
   {0.,1.,0.},  {1.,1.,0.},  {2.,1.,0.},
   {0.,0.,2.},  {1.,0.,2.},  {2.,0.,2.},
   {0.,1.,2.},  {1.,1.,2.},  {2.,1.,2.} };

                   /* user node ids */ 
static Vint nid[MAX_NODE] = {
   1, 2, 3, 4, 5, 6, 7, 8, 9,20,21,22 };

/*----------------------------------------------------------------------
                      Export a simple linear static solveable Model
----------------------------------------------------------------------*/
int
main()
{
   Vint i;
   vis_Model *model;
   vis_Connect *connect;
   vis_GridFun *gf;
   vis_MProp *mprop;
   vis_EProp *eprop;
   vis_SProp *sprop;
   vis_RCase *rcase;
   vis_LCase *lcase;
   vsy_HashTable *ephash, *mphash, *rchash, *lchash;
   vsy_List *splist;
   Vdouble pres[4];
   Vint nix, conntran[8];
   Vint id;
   Vint res[2];

                   /* create connect object */
   connect = vis_ConnectBegin ();
   vis_ConnectPre (connect,SYS_DOUBLE);
   vis_ConnectDef (connect,MAX_NODE,MAX_ELEM);

                   /* set node coordinates and user ids */ 
   for(i = 0; i < MAX_NODE; i++) {
      vis_ConnectSetCoordsdv (connect,i+1,coords[i]);
      vis_ConnectSetNodeAssoc (connect,VIS_USERID,i+1,nid[i]);
   }
                   /* set element topologies */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetTopology (connect,i+1,shap[i],maxi[i],0,0);
   }
                   /* set element node connectivity and associations */ 
   for(i = 0; i < MAX_ELEM; i++) {
                   /* translate connectivity in user ids to
                      1,...,MAX_NODE index space */ 
      vis_ConnectElemNum (connect,SYS_NODE,i+1,&nix);
      vis_ConnectNodeIndices (connect,nix,conn[i],conntran);
      vis_ConnectSetElemNode (connect,i+1,conntran);
      vis_ConnectSetElemAssoc (connect,VIS_USERID,i+1,eid[i]);
      vis_ConnectSetElemAssoc (connect,VIS_FEATYPE,i+1,featype[i]);
      vis_ConnectSetElemAssoc (connect,VIS_PROPID,i+1,pid[i]);
   }

                   /* create model object hierarchy */ 
   model = vis_ModelBegin ();

                   /* hashtables of element and material properties */
   ephash = vsy_HashTableBegin ();
   mphash = vsy_HashTableBegin ();

                   /* hashtables of restraint and load cases */
   rchash = vsy_HashTableBegin ();
   lchash = vsy_HashTableBegin ();

                   /* list of solution procedures */ 
   splist = vsy_ListBegin ();

                   /* material 1 */ 
   mprop = vis_MPropBegin ();
   vis_MPropDef (mprop,SYS_MAT_ISOTROPIC);
   vis_MPropSetValued (mprop,MPROP_E,1.e+7);
   vis_MPropSetValued (mprop,MPROP_NU,.3);
   vis_MPropSetValued (mprop,MPROP_DENSITY,1.e-05);
   vsy_HashTableInsert (mphash,1,mprop);

                   /* solid property 1 */ 
   eprop = vis_EPropBegin ();
   vis_EPropDef (eprop,VIS_ELEM_SOLID);
   vis_EPropSetValuei (eprop,EPROP_MID,1);
   vsy_HashTableInsert (ephash,1,eprop);

                   /* GridFun for use with LCase objects with element loads */ 
   gf = vis_GridFunBegin ();
   vis_ConnectGridFun (connect,gf);

                   /* restraint case 1 */ 
                   /* fix nodes 1, 4, 7, 20 in x */
                   /* fix node 4 in z, node 7 in y */
   rcase = vis_RCaseBegin ();
   vis_ConnectNodeIndex (connect,1,&id);
   vis_RCaseSetSPC (rcase,id,SYS_DOF_TX,RCASE_FIXED,NULL,0);
   vis_RCaseSetSPC (rcase,id,SYS_DOF_TY,RCASE_FIXED,NULL,0);
   vis_RCaseSetSPC (rcase,id,SYS_DOF_TZ,RCASE_FIXED,NULL,0);
   vis_ConnectNodeIndex (connect,4,&id);
   vis_RCaseSetSPC (rcase,id,SYS_DOF_TX,RCASE_FIXED,NULL,0);
   vis_RCaseSetSPC (rcase,id,SYS_DOF_TZ,RCASE_FIXED,NULL,0);
   vis_ConnectNodeIndex (connect,7,&id);
   vis_RCaseSetSPC (rcase,id,SYS_DOF_TX,RCASE_FIXED,NULL,0);
   vis_RCaseSetSPC (rcase,id,SYS_DOF_TY,RCASE_FIXED,NULL,0);
   vis_ConnectNodeIndex (connect,20,&id);
   vis_RCaseSetSPC (rcase,id,SYS_DOF_TX,RCASE_FIXED,NULL,0);
   vsy_HashTableInsert (rchash,1,rcase);

                   /* load case 1 */ 
                   /* uniform pressure on face 6 element 20 */ 
                   /* register GridFun object with LCase */
   lcase = vis_LCaseBegin ();
   vis_LCaseSetObject (lcase,VIS_GRIDFUN,gf);
   pres[0] = 50.;
   pres[1] = 50.;
   pres[2] = 50.;
   pres[3] = 50.;
   vis_ConnectElemIndex (connect,20,&id);
   vis_LCaseSetDistdv (lcase,SYS_FACE,id,6,LCASE_PRES,pres);
   vsy_HashTableInsert (lchash,1,lcase);

                   /* solution step 1 */
   sprop = vis_SPropBegin ();
   vis_SPropDef (sprop,SYS_SOL_STATIC);
   vis_SPropSetValuei (sprop,SPROP_ANALYSIS,SYS_ANALYSIS_STRUCTURAL);
   vis_SPropSetValuei (sprop,SPROP_CASEID,1);
   vis_SPropSetValuei (sprop,SPROP_RCASE,1);
   vis_SPropSetValued (sprop,SPROP_RCASE_FACTOR,1.);
   vis_SPropSetValuei (sprop,SPROP_LCASE_NUM,1);
   vis_SPropSetValuei (sprop,SPROP_LCASE,1);
   vis_SPropSetValued (sprop,SPROP_LCASE_FACTOR,1.);
                   /* output requests, displacement, stress */ 
   res[0] = SYS_RES_D;
   res[1] = SYS_RES_S;
   vis_SPropSetValuei (sprop,SPROP_RESPRINT_NUM,2);
   vis_SPropSetValueiv (sprop,SPROP_RESPRINT,res);
   vis_SPropSetValuei (sprop,SPROP_RESFILE_NUM,2);
   vis_SPropSetValueiv (sprop,SPROP_RESFILE,res);
   vsy_ListInsert (splist,1,sprop);

                   /* register Connect in Model */ 
   vis_ModelSetObject (model,VIS_CONNECT,connect);

                   /* register property hashtables in Model */ 
   vis_ModelSetHashTable (model,VIS_MPROP,mphash);
   vis_ModelSetHashTable (model,VIS_EPROP,ephash);

                   /* register case hashtables in Model */ 
   vis_ModelSetHashTable (model,VIS_RCASE,rchash);
   vis_ModelSetHashTable (model,VIS_LCASE,lchash);

                   /* register solution property list in Model */ 
   vis_ModelSetList (model,VIS_SPROP,splist);

                   /* write NASTRAN Bulk Data File */ 
   vis_ModelWrite (model,SYS_NASTRAN_BULKDATA,"exam39.bdf");
                   /* write ABAQUS Input Data File */ 
   vis_ModelWrite (model,SYS_ABAQUS_INPUT,"exam39.inp");
                   /* write ANSYS Input Data File */ 
   vis_ModelWrite (model,SYS_ANSYS_INPUT,"exam39.cdb");
                   /* write LS-DYNA Input Data File */ 
   vis_ModelWrite (model,SYS_LSTC_INPUT,"exam39.k");

                   /* end objects */ 
   vis_GridFunEnd (gf);
                   /* Use convenience routine ModelDelete to destroy
                      all objects registered in Model */
   vis_ModelDelete (model);
                   /* finally destroy Model object */ 
   vis_ModelEnd (model);
   return 0;
}
BP Table of Contents

25.39 Example 39a, Structural Finite Element Model Using Model

This example illustrates the use of a Model object hierarchy to manage a more complex structural finite element model than in Example 39. All supported element types for export are illustrated.

The objects contained in the Model object are explicitly deleted in this example, however the vis_ModelDelete function could have been used to perform the same operation.

#include "base/base.h"
#include "vis/vis.h"
/*
                 5------6
                /.     /.\
               / .    / . \
              /  .   /  .  \70------80             20
             /   1../...2../|       |  \           |
           12-----13-----14 |       |    \        rbe2
            |  .   |  .   |.|       |      \       |
            | .    | .    | 30------40------15-----18
            |.     |.     |/                 |\      \
            9-----10-----11                  rbe3      \
            \      /    /                    |  \        \ 
             \tet /wed /                    21   22       19
              \  /    /
               16----17
*/
#define MAX_ELEM 11
#define MAX_NODE 22

                   /* element connectivity */ 
static Vint conn[MAX_ELEM][8] = {
 { 1, 2, 6, 5, 9,10,13,12},
 { 2,30,70, 6,10,11,14,13},
 {30,40,80,70, 0, 0, 0, 0},
 {40,15,80, 0, 0, 0, 0, 0},
 { 9,10,13,16, 0, 0, 0, 0},
 {10,13,16,11,14,17, 0, 0},
 {15,18, 0, 0, 0, 0, 0, 0},
 {18, 0, 0, 0, 0, 0, 0, 0},
 {18,19, 0, 0, 0, 0, 0, 0},
 {18,20, 0, 0, 0, 0, 0, 0},
 {15,21,22, 0, 0, 0, 0, 0} };

                   /* user element ids */ 
static Vint eid[MAX_ELEM] = {
   10,11,20,21,30,31,100,101,102,103,104 };

                   /* element topologies */ 
static Vint shap[MAX_ELEM] = {
   VIS_SHAPEHEX, VIS_SHAPEHEX, VIS_SHAPEQUAD, VIS_SHAPETRI,
   VIS_SHAPETET, VIS_SHAPEWED, VIS_SHAPELINE, VIS_SHAPEPOINT,
   VIS_SHAPELINE, VIS_SHAPEPOINT, VIS_SHAPEPOINT };
static Vint maxi[MAX_ELEM] = {
   0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3 };

                   /* element types */ 
static Vint featype[MAX_ELEM] = {
   VIS_ELEM_SOLID, VIS_ELEM_SOLID, VIS_ELEM_SHELL, VIS_ELEM_SHELL,
   VIS_ELEM_SOLID, VIS_ELEM_SOLID, VIS_ELEM_BEAM,  VIS_ELEM_MASS,
   VIS_ELEM_SPRINGDASHPOT, VIS_ELEM_RIGID, VIS_ELEM_RIGID };

                   /* element specs */ 
static Vint feaspec[MAX_ELEM] = {
   0, 0, 0, 0,
   0, 0, 0, 0,
   SYS_SPRINGDASHPOT_LINK, SYS_RIGID_KINE, SYS_RIGID_DIST };

                   /* element property ids */ 
static Vint pid[MAX_ELEM] = {
   1, 1, 2, 2, 1, 1, 3, 4, 5, 6, 8 };

                   /* element coordinate system indicators and ids */ 
static Vint ecid[MAX_ELEM] = {
   0, 0, 0, 0, 0, 0, SYS_ELEMSYS_VECTOR, 0, 1, 0, 0 };

                   /* node coordinates */ 
static Vdouble coords[MAX_NODE][3] = {
   {0.,0.,0.},  {1.,0.,0.},  {2.,0.,1.}, {3.,0.,1.}, 
   {0.,1.,0.},  {1.,1.,0.},  {2.,1.,1.}, {3.,1.,1.}, 
   {0.,0.,2.},  {1.,0.,2.},  {2.,0.,2.},
   {0.,1.,2.},  {1.,1.,2.},  {2.,1.,2.},
   {4.,0.,1.},  {1.,0.,3.},  {2.,0.,3.}, {5.,0.,1.}, {6.,-1.,1.},
   {5.,1.,1.},  {4.,-1.,1.}, {4.5,-1.,1.} };

                   /* user node ids */ 
static Vint nid[MAX_NODE] = {
   1, 2,30,40, 5, 6,70,80, 9,10,11,12,13,14,15,16,17,18,19,20,21,22 };

/*----------------------------------------------------------------------
                      Manage a Structural Finite Element Model Using Model
----------------------------------------------------------------------*/
int
main()
{
   Vint i;
   vis_Model *model;
   vis_Connect *connect;
   vis_Units *units;
   vis_ElemDat *elemdatthk, *elemdatvec;
   vis_GridFun *gf;
   vis_CoordSys *coordsys;
   vis_MProp *mprop;
   vis_EProp *eprop;
   vis_SProp *sprop;
   vis_RCase *rcase;
   vis_LCase *lcase;
   vis_CPair *cpair;
   vsy_HashTable *cshash, *ephash, *mphash, *edhash, *rchash, *lchash, *cphash;
   vsy_List *splist;
   Vdouble xo[3], tm[3][3];
   Vdouble force[3], temp;
   Vdouble thk[3];
   Vdouble vec[3], pres[4];
   Vint dofflag[2];
   vis_IdTran *idtrannode, *idtranelem;
   Vint nix, conntran[8];
   Vint id;

                   /* create connect object */
   connect = vis_ConnectBegin ();
   vis_ConnectPre (connect,SYS_DOUBLE);
   vis_ConnectDef (connect,MAX_NODE,MAX_ELEM);

                   /* set up user node and element id translation */ 
   idtrannode = vis_IdTranBegin();
   for(i = 0; i < MAX_NODE; i++) {
      vis_IdTranSetId (idtrannode,i+1,nid[i]);
   }
   idtranelem = vis_IdTranBegin();
   for(i = 0; i < MAX_ELEM; i++) {
      vis_IdTranSetId (idtranelem,i+1,eid[i]);
   }
                   /* set node coordinates */ 
   for(i = 0; i < MAX_NODE; i++) {
      vis_ConnectSetCoordsdv (connect,i+1,coords[i]);
      vis_ConnectSetNodeAssoc (connect,VIS_USERID,i+1,nid[i]);
   }

                   /* set element topologies */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetTopology (connect,i+1,shap[i],maxi[i],0,0);
   }

                   /* set element node connectivity and associations */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectElemNum (connect,SYS_NODE,i+1,&nix);
      vis_IdTranIndices (idtrannode,nix,conn[i],conntran);
      vis_ConnectSetElemNode (connect,i+1,conntran);
      vis_ConnectSetElemAssoc (connect,VIS_USERID,i+1,eid[i]);
      vis_ConnectSetElemAssoc (connect,VIS_FEATYPE,i+1,featype[i]);
      vis_ConnectSetElemAssoc (connect,VIS_FEASPEC,i+1,feaspec[i]);
      vis_ConnectSetElemAssoc (connect,VIS_PROPID,i+1,pid[i]);
      vis_ConnectSetElemAssoc (connect,VIS_CSYSID,i+1,ecid[i]);
   }

                   /* create model object hierarchy */ 
   model = vis_ModelBegin ();

                   /* hashtables of coordinate systems */
   cshash = vsy_HashTableBegin ();

                   /* hashtables of element and material properties */
   ephash = vsy_HashTableBegin ();
   mphash = vsy_HashTableBegin ();

                   /* hashtables of element data */
   edhash = vsy_HashTableBegin ();

                   /* hashtables of restraint and load cases */
   rchash = vsy_HashTableBegin ();
   lchash = vsy_HashTableBegin ();

                   /* hashtable of contact pairs */ 
   cphash = vsy_HashTableBegin ();

                   /* list of solution procedures */ 
   splist = vsy_ListBegin ();

                   /* units */
   units = vis_UnitsBegin ();
   vis_UnitsSetBase (units,UNITS_LENGTH,UNITS_LENGTH_MILLIMETER);
   vis_UnitsSetBase (units,UNITS_MASS,UNITS_MASS_KILOGRAM);
   vis_UnitsSetBase (units,UNITS_TEMP,UNITS_TEMP_KELVIN);

                   /* coordinate system 1 for spring element */ 
   coordsys = vis_CoordSysBegin ();
   vis_CoordSysDef (coordsys,SYS_CARTESIAN);
   xo[0] = 0.;
   xo[1] = 0.;
   xo[2] = 0.;
   tm[0][0] = .7071; tm[0][1] = -.7071;  tm[0][2] = 0.;
   tm[1][0] = .7071; tm[1][1] =  .7071;  tm[1][2] = 0.;
   tm[2][0] = 0.;    tm[2][1] =  0.;     tm[2][2] = 1.;
   vis_CoordSysSetOriginTriaddv (coordsys,xo,tm);
   vsy_HashTableInsert (cshash,1,coordsys);

                   /* material 1 */ 
   mprop = vis_MPropBegin ();
   vis_MPropDef (mprop,SYS_MAT_ISOTROPIC);
   vis_MPropSetValued (mprop,MPROP_E,1.e+7);
   vis_MPropSetValued (mprop,MPROP_NU,.3);
   vis_MPropSetValued (mprop,MPROP_DENSITY,0.0000133);
   vsy_HashTableInsert (mphash,1,mprop);

                   /* solid property 1 */ 
   eprop = vis_EPropBegin ();
   vis_EPropDef (eprop,VIS_ELEM_SOLID);
   vis_EPropSetValuei (eprop,EPROP_MID,1);
   vsy_HashTableInsert (ephash,1,eprop);

                   /* shell property 2 */ 
   eprop = vis_EPropBegin ();
   vis_EPropDef (eprop,VIS_ELEM_SHELL);
   vis_EPropSetValuei (eprop,EPROP_MID,1);
   vis_EPropSetValued (eprop,EPROP_THICKNESS,.5);
   vsy_HashTableInsert (ephash,2,eprop);

                   /* beam property 3 */
   eprop = vis_EPropBegin ();
   vis_EPropDef (eprop,VIS_ELEM_BEAM);
   vis_EPropSetValuei (eprop,EPROP_MID,1);
   vis_EPropSetValued (eprop,EPROP_AREA,2.0);
   vsy_HashTableInsert (ephash,3,eprop);

                   /* mass property 4 */
   eprop = vis_EPropBegin ();
   vis_EPropDef (eprop,VIS_ELEM_MASS);
   vis_EPropSetValued (eprop,EPROP_MASS,3.0);
   vsy_HashTableInsert (ephash,4,eprop);

                   /* spring property 5 */
   eprop = vis_EPropBegin ();
   vis_EPropDef (eprop,VIS_ELEM_SPRINGDASHPOT);
                   /* x-translation at node 1, y-translation at node 2 */
   vis_EPropSetValuei (eprop,EPROP_DOF1,SYS_DOF_TX);
   vis_EPropSetValuei (eprop,EPROP_DOF2,SYS_DOF_TY);
   vis_EPropSetValued (eprop,EPROP_STIFF,100000.0);
   vsy_HashTableInsert (ephash,5,eprop);

                   /* rigid (RBE2 type) element property 6 */
   eprop = vis_EPropBegin ();
   vis_EPropDef (eprop,SYS_ELEM_RIGID);
   vis_EPropSetValuei (eprop,EPROP_DOFFLAG_NUM,2);
                   /* x,y,z translations and rotations at independent node */
   dofflag[0] = (1 << (SYS_DOF_TX-1)) | 
                (1 << (SYS_DOF_TY-1)) | 
                (1 << (SYS_DOF_TZ-1)) |
                (1 << (SYS_DOF_RX-1)) |
                (1 << (SYS_DOF_RY-1)) |
                (1 << (SYS_DOF_RZ-1));
   dofflag[1] = 0;
   vis_EPropSetValueiv (eprop,EPROP_DOFFLAG_IND,dofflag);
                   /* x,y,z translations at dependent node */
   dofflag[0] = 0;
   dofflag[1] = (1 << (SYS_DOF_TX-1)) | 
                (1 << (SYS_DOF_TY-1)) | 
                (1 << (SYS_DOF_TZ-1));
   vis_EPropSetValueiv (eprop,EPROP_DOFFLAG_DEP,dofflag);
                   /* optional penalty, may or may not be used */
   vis_EPropSetValued (eprop,EPROP_PENALTY,1.0e+12);
   vsy_HashTableInsert (ephash,6,eprop);

                   /* gap property 7 */
   eprop = vis_EPropBegin ();
   vis_EPropDef (eprop,VIS_ELEM_GAP);
   vis_EPropSetValuei (eprop,EPROP_NOSLIP,SYS_ON);
   vis_EPropSetValuei (eprop,EPROP_NOSEPARATION,SYS_ON);
   vsy_HashTableInsert (ephash,7,eprop);

                   /* rigid (RBE3 type) element property 8 */
   eprop = vis_EPropBegin ();
   vis_EPropDef (eprop,SYS_ELEM_RIGID);
   vis_EPropSetValuei (eprop,EPROP_DOFFLAG_NUM,2);
                   /* x,y,z translations and rotations at reference node */
   dofflag[0] = (1 << (SYS_DOF_TX-1)) | 
                (1 << (SYS_DOF_TY-1)) | 
                (1 << (SYS_DOF_TZ-1)) |
                (1 << (SYS_DOF_RX-1)) |
                (1 << (SYS_DOF_RY-1)) |
                (1 << (SYS_DOF_RZ-1));
   dofflag[1] = 0;
   vis_EPropSetValueiv (eprop,EPROP_DOFFLAG_DEP,dofflag);
                   /* x,y,z translations at distributing nodes */
   dofflag[0] = 0;
   dofflag[1] = (1 << (SYS_DOF_TX-1)) | 
                (1 << (SYS_DOF_TY-1)) | 
                (1 << (SYS_DOF_TZ-1));
   vis_EPropSetValueiv (eprop,EPROP_DOFFLAG_IND,dofflag);
   vis_EPropSetValued (eprop,EPROP_DOFFLAG_WGTS,2.);
                   /* optional penalty, may or may not be used */
   vis_EPropSetValued (eprop,EPROP_PENALTY,1.0e+12);
   vsy_HashTableInsert (ephash,8,eprop);

                   /* GridFun */ 
   gf = vis_GridFunBegin ();
   vis_ConnectGridFun (connect,gf);

                   /* ElemDat of shell element node thickness */ 
   elemdatthk = vis_ElemDatBegin ();
   vis_ElemDatDef (elemdatthk,MAX_ELEM,SYS_ELEM,SYS_NODE,SYS_SCALAR);
   vis_ElemDatSetObject (elemdatthk,VIS_GRIDFUN,gf);

                   /* ElemDat of beam element orientation vectors */ 
   elemdatvec = vis_ElemDatBegin ();
   vis_ElemDatDef (elemdatvec,MAX_ELEM,SYS_ELEM,SYS_NONE,SYS_VECTOR);
   vis_ElemDatSetObject (elemdatvec,VIS_GRIDFUN,gf);

                   /* shell element 21 is tapered */ 
   thk[0] = .5;
   thk[1] = .3;
   thk[2] = .5;
   vis_IdTranIndex (idtranelem,21,&id);
   vis_ElemDatSetDatadv (elemdatthk,id,0,thk);
   vsy_HashTableInsert (edhash,SYS_PROP_THICKNESS,elemdatthk);

                   /* beam element 100 orientation vector */ 
   vec[0] = 0.;
   vec[1] = 1.;
   vec[2] = 0.;
   vis_IdTranIndex (idtranelem,100,&id);
   vis_ElemDatSetDatadv (elemdatvec,id,0,vec);
   vsy_HashTableInsert (edhash,SYS_PROP_ELEMVEC,elemdatvec);

                   /* contact pair, hex element 11 face 6 and shell element 20
                      use gap property 7 */ 
   cpair = vis_CPairBegin ();
   vis_CPairDef (cpair,SYS_FACE,SYS_FACE);
   vis_CPairSetObject (cpair,VIS_GRIDFUN,gf);
   vis_IdTranIndex (idtranelem,11,&id);
   vis_CPairSetMaster (cpair,id,6);
   vis_IdTranIndex (idtranelem,20,&id);
   vis_CPairSetSlaveElem (cpair,id,1);
   vis_CPairSetValuei (cpair,CPAIR_PID,7);
   vis_CPairSetValued (cpair,CPAIR_ADJUST,.1);
   vsy_HashTableInsert (cphash,1,cpair);

                   /* restraint case 1 */ 
   rcase = vis_RCaseBegin ();
   for(i = 1; i <= 3; i++) {
      vis_RCaseSetSPC (rcase,i,SYS_DOF_TX,RCASE_FIXED,NULL,0);
      vis_RCaseSetSPC (rcase,i,SYS_DOF_TY,RCASE_FIXED,NULL,0);
      vis_RCaseSetSPC (rcase,i,SYS_DOF_TZ,RCASE_FIXED,NULL,0);
   }
   vsy_HashTableInsert (rchash,1,rcase);

                   /* load case 1 */ 
   lcase = vis_LCaseBegin ();

                   /* concentrated force on node 12 */ 
   force[0] = 1.;
   force[1] = 2.;
   force[2] = 3.;
   vis_IdTranIndex (idtrannode,12,&id);
   vis_LCaseSetConcdv (lcase,id,LCASE_FORCE,force);

                   /* temperatures on nodes 16 and 17 */ 
   vis_IdTranIndex (idtrannode,16,&id);
   temp = 100.;
   vis_LCaseSetConcdv (lcase,id,LCASE_TEMP,&temp);
   vis_IdTranIndex (idtrannode,17,&id);
   temp = 200.;
   vis_LCaseSetConcdv (lcase,id,LCASE_TEMP,&temp);

                   /* uniform pressure on face 2 element 10 */ 
                   /* register GridFun object with LCase */
   vis_LCaseSetObject (lcase,VIS_GRIDFUN,gf);
   pres[0] = 50.;
   pres[1] = 50.;
   pres[2] = 50.;
   pres[3] = 50.;
   vis_IdTranIndex (idtranelem,10,&id);
   vis_LCaseSetDistdv (lcase,SYS_FACE,id,2,LCASE_PRES,pres);
   vsy_HashTableInsert (lchash,1,lcase);

                   /* solution step 1 */
   sprop = vis_SPropBegin ();
   vis_SPropDef (sprop,SYS_SOL_STATIC);
   vis_SPropSetValuei (sprop,SPROP_CASEID,1);
   vis_SPropSetValuei (sprop,SPROP_NONLINEAR,1);
   vis_SPropSetValuei (sprop,SPROP_RCASE,1);
   vis_SPropSetValued (sprop,SPROP_RCASE_FACTOR,1.);
   vis_SPropSetValuei (sprop,SPROP_LCASE_NUM,1);
   vis_SPropSetValuei (sprop,SPROP_LCASE,1);
   vis_SPropSetValued (sprop,SPROP_LCASE_FACTOR,1.);
   vis_SPropSetValued (sprop,SPROP_TIME_INIT,.2);
   vis_SPropSetValued (sprop,SPROP_TIME_STEP,.1);
   vis_SPropSetValued (sprop,SPROP_TIME_TERM,1.);
   vsy_ListInsert (splist,1,sprop);

                   /* register Connect in Model */ 
   vis_ModelSetObject (model,VIS_CONNECT,connect);

                   /* register Units in Model */ 
   vis_ModelSetObject (model,VIS_UNITS,units);

                   /* register coordinate system hashtables in Model */ 
   vis_ModelSetHashTable (model,VIS_COORDSYS,cshash);

                   /* register property hashtables in Model */ 
   vis_ModelSetHashTable (model,VIS_MPROP,mphash);
   vis_ModelSetHashTable (model,VIS_EPROP,ephash);

                   /* register element data hashtables in Model */ 
   vis_ModelSetHashTable (model,VIS_ELEMDAT,edhash);

                   /* register case hashtables in Model */ 
   vis_ModelSetHashTable (model,VIS_RCASE,rchash);
   vis_ModelSetHashTable (model,VIS_LCASE,lchash);

                   /* register contact pair hashtable in Model */ 
   vis_ModelSetHashTable (model,VIS_CPAIR,cphash);

                   /* register solution property list in Model */ 
   vis_ModelSetList (model,VIS_SPROP,splist);

                   /* print to standard output */
   vis_ModelPrint (model);
                   /* write NASTRAN Bulk Data File */ 
   vis_ModelWrite (model,SYS_NASTRAN_BULKDATA,"exam39a.bdf");
                   /* write ABAQUS Input Data File */ 
   vis_ModelWrite (model,SYS_ABAQUS_INPUT,"exam39a.inp");
                   /* write ANSYS Input Data File */ 
   vis_ModelWrite (model,SYS_ANSYS_INPUT,"exam39a.cdb");
                   /* write Ideas Universal File */
   vis_ModelWrite (model,SYS_SDRC_UNIVERSAL,"exam39a.unv");
                    /* write PATRAN Neutral File */
   vis_ModelWrite (model,SYS_PATRAN_NEUTRAL,"exam39a.out");
                    /* write LS-DYNA Input Data File */
   vis_ModelWrite (model,SYS_LSTC_INPUT,"exam39a.k");

                   /* end objects */ 
   vis_IdTranEnd (idtrannode);
   vis_IdTranEnd (idtranelem);
   vis_GridFunEnd (gf);
   vis_ConnectEnd (connect);
   vis_UnitsEnd (units);
   vsy_HashTableForEach (cshash,(void(*)(Vobject*))vis_CoordSysEnd);
   vsy_HashTableEnd (cshash);
   vsy_HashTableForEach (ephash,(void(*)(Vobject*))vis_EPropEnd);
   vsy_HashTableEnd (ephash);
   vsy_HashTableForEach (mphash,(void(*)(Vobject*))vis_MPropEnd);
   vsy_HashTableEnd (mphash);
   vsy_HashTableForEach (edhash,(void(*)(Vobject*))vis_ElemDatEnd);
   vsy_HashTableEnd (edhash);
   vsy_HashTableForEach (cphash,(void(*)(Vobject*))vis_CPairEnd);
   vsy_HashTableEnd (cphash);
   vsy_ListForEach (splist,(void(*)(Vobject*))vis_SPropEnd);
   vsy_ListEnd (splist);
   vsy_HashTableForEach (rchash,(void(*)(Vobject*))vis_RCaseEnd);
   vsy_HashTableEnd (rchash);
   vsy_HashTableForEach (lchash,(void(*)(Vobject*))vis_LCaseEnd);
   vsy_HashTableEnd (lchash);
   vis_ModelEnd (model);
   return 0;
}

Table of Contents

25.40 Example 39b, Traverse and Print Contents of a Model Object

This example illustrates loading a Model object with a finite element model residing on an external file and then traversing and printing the contents of the Model object. The finite element model may reside on any external file in a format supported by VdmTools. The external file name is entered as the first argument to the example executable. If no file name is entered then the file "shell.bdf", a simple NASTRAN bulk data file, is assumed. The model object is created and then loaded using the function vdm_LManLoadModel. During this process many objects are created and registered in the Model object by the function. These objects represent the various components of the finite element model. Once the model is loaded then all VdmTools objects required to load the model may be deleted.

The Model object is now systematically traversed by accessing the component objects registered in it in turn.

Each Model component is traversed and printed by an associated function within the example. All objects registered in the Model object may be conveniently deleted using vis_ModelDelete. The Model object itself is deleted using vis_ModelEnd.

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

static void
printGProp(vis_GProp *gprop);
static void
printConnect(vis_Connect *connect);
static void
printIdTran(vsy_HashTable *nehash);
static void
printCoordSys(vsy_HashTable *coordsyshash);
static void
printUnits(vis_Units *units);
static void
printEProp(vsy_HashTable *ephash);
static void
printMProp(vsy_HashTable *mphash);
static void
printTCurve(vsy_HashTable *tchash);
static void
printElemDat(vsy_HashTable *edhash, vis_Connect *connect);
static void
printLCase(vsy_HashTable *lchash, vis_Connect *connect);
static void
printRCase(vsy_HashTable *rchash, vis_Connect *connect);
static void
printMCase(vsy_HashTable *mchash, vis_Connect *connect);
static void
printCPair(vsy_HashTable *cphash, vis_Connect *connect);
static void
printASurf(vsy_HashTable *ashash, vis_Connect *connect);
static void
printSProp(vsy_List *splist);

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

/*----------------------------------------------------------------------
                      Traverse and print contents of a Model object
----------------------------------------------------------------------*/
int
main(int argc, char **argv)
{
   char inputfile[256];
   vdm_ABAFil  *abafil;
   vdm_ABALib  *abalib;
   vdm_ANSFil  *ansfil;
   vdm_ANSLib  *anslib;
   vdm_D3DFil  *d3dfil;
   vdm_D3DLib  *d3dlib;
   vdm_NASFil  *nasfil;
   vdm_PAMFil  *pamfil;
   vdm_NASLib  *naslib;
   vdm_NatLib  *natlib;
   vdm_RASLib  *raslib;
   vdm_MarcLib *marclib;
   vdm_SDRCLib *sdrclib;
   vdm_PatLib  *patlib;
   vdm_CGNSVLib *cgnsvlib;
   vdm_FLUENTLib *fluentlib;
   vdm_DataFun *datafun;
   vdm_LMan    *lman;
   Vint filetype;
   vis_Model *model;
   vis_GProp *gprop;
   vis_Connect *connect;
   vis_Units *units;
   vsy_HashTable *coordsyshash;
   vsy_HashTable *eprophash;
   vsy_HashTable *mprophash;
   vsy_HashTable *tcurvehash;
   vsy_HashTable *lcasehash;
   vsy_HashTable *rcasehash;
   vsy_HashTable *mcasehash;
   vsy_HashTable *cpairhash;
   vsy_HashTable *asurfhash;
   vsy_HashTable *elemdathash;
   vsy_HashTable *nsethash;
   vsy_HashTable *esethash;
   vsy_HashTable *eenthash;
   vsy_List *sproplist;

   if(argc < 2) {
      fprintf(stderr,"Usage: %s inputfile\n",argv[0]);
      fprintf(stderr," inputfile is blank, 'shell.bdf' is assumed\n");
      strcpy(inputfile,"shell.bdf");
   } else {
      strcpy(inputfile,argv[1]);
   }

                   /* create data function object */
   datafun = vdm_DataFunBegin ();

                   /* determine file type from file extension */
   if(strstr(inputfile,".bdf") != NULL  ||
      strstr(inputfile,".dat") != NULL) {
      filetype = VDM_NASTRAN_BULKDATA;
      nasfil = vdm_NASFilBegin ();
      vdm_NASFilDataFun (nasfil,datafun);
      printf("Nastran Bulk Data File: %s\n",inputfile);
   } else if(strstr(inputfile,".op2") != NULL) {
      filetype = VDM_NASTRAN_OUTPUT2;
      naslib = vdm_NASLibBegin ();
      vdm_NASLibDataFun (naslib,datafun);
      printf("Nastran Output2 File: %s\n",inputfile);
   } else if(strstr(inputfile,".vdm") != NULL) {
      filetype = VDM_NATIVE;
      natlib = vdm_NatLibBegin ();
      vdm_NatLibDataFun (natlib,datafun);
      printf("Native File: %s\n",inputfile);
   } else if(strstr(inputfile,".pc") != NULL) {
      filetype = VDM_PAM_INPUT;
      pamfil = vdm_PAMFilBegin ();
      vdm_PAMFilDataFun (pamfil,datafun);
      printf("PAM Input File: %s\n",inputfile);
   } else if(strstr(inputfile,".inp") != NULL) {
      filetype = VDM_ABAQUS_INPUT;
      abafil = vdm_ABAFilBegin ();
      vdm_ABAFilDataFun (abafil,datafun);
      printf("Abaqus Input File: %s\n",inputfile);
   } else if(strstr(inputfile,".fil") != NULL) {
      filetype = VDM_ABAQUS_FIL;
      abalib = vdm_ABALibBegin ();
      vdm_ABALibDataFun (abalib,datafun);
      printf("Abaqus Binary (.fil) File: %s\n",inputfile);
   } else if(strstr(inputfile,".odb") != NULL) {
      filetype = VDM_ABAQUS_ODB;
      abalib = vdm_ABALibBegin ();
      vdm_ABALibDataFun (abalib,datafun);
      printf("Abaqus Output (.odb) File: %s\n",inputfile);
   } else if(strstr(inputfile,".cdb") != NULL) {
      filetype = VDM_ANSYS_INPUT;
      ansfil = vdm_ANSFilBegin ();
      vdm_ANSFilDataFun (ansfil,datafun);
      printf("Ansys Input File: %s\n",inputfile);
   } else if(strstr(inputfile,".rst") != NULL) {
      filetype = VDM_ANSYS_RESULT;
      anslib = vdm_ANSLibBegin ();
      vdm_ANSLibDataFun (anslib,datafun);
      printf("Ansys Result (.rst) File: %s\n",inputfile);
   } else if(strstr(inputfile,".k") != NULL) {
      filetype = VDM_LSTC_INPUT;
      d3dfil = vdm_D3DFilBegin ();
      vdm_D3DFilDataFun (d3dfil,datafun);
      printf("LS-DYNA Input File: %s\n",inputfile);
   } else if(strstr(inputfile,"d3plot") != NULL) {
      filetype = VDM_LSTC_STATE;
      d3dlib = vdm_D3DLibBegin ();
      vdm_D3DLibDataFun (d3dlib,datafun);
      printf("LS-DYNA State Database: %s\n",inputfile);
   } else if(strstr(inputfile,".neu") != NULL) {
      filetype = VDM_MECHANICA_STUDY;
      raslib = vdm_RASLibBegin();
      vdm_RASLibDataFun (raslib,datafun);
      printf("PTC Mechanica Study: %s\n",inputfile);
   } else if(strstr(inputfile,".unv") != NULL ||
             strstr(inputfile,".bun") != NULL) {
      filetype = VDM_SDRC_UNIVERSAL;
      sdrclib = vdm_SDRCLibBegin ();
      vdm_SDRCLibDataFun (sdrclib,datafun);
      printf("SDRC Universal File: %s\n",inputfile);
   } else if(strstr(inputfile,".out") != NULL) {
      filetype = VDM_PATRAN_NEUTRAL;
      patlib = vdm_PatLibBegin ();
      vdm_PatLibDataFun (patlib,datafun);
      printf("MSC/PATRAN Neutral File: %s\n",inputfile);
   } else if(strstr(inputfile,".cgns") != NULL) {
      filetype = VDM_CGNS;
      cgnsvlib = vdm_CGNSVLibBegin ();
      vdm_CGNSVLibDataFun (cgnsvlib,datafun);
      printf("CGNS Data File: %s\n",inputfile);
   } else if(strstr(inputfile,".cas") != NULL  ||
             strstr(inputfile,".msh") != NULL) {
      filetype = VDM_FLUENT_MESH;
      fluentlib = vdm_FLUENTLibBegin();
      vdm_FLUENTLibDataFun (fluentlib,datafun);
      printf("Fluent Mesh File: %s\n",inputfile);
   } else if(strstr(inputfile,".t16") != NULL  ||
             strstr(inputfile,".t19") != NULL) {
      filetype = VDM_MARC_POST;
      marclib = vdm_MarcLibBegin();
      vdm_MarcLibDataFun (marclib,datafun);
      printf("Marc File: %s\n",inputfile);
   } else {
      fprintf(stderr,"Error: Bad input file %s\n",inputfile);
      exit(1);
   }
                   /* open library device */
   vdm_DataFunOpen (datafun,0,inputfile,filetype);

                   /* instance model object for finite element model */
   model = vis_ModelBegin();

                   /* use Library Manager object to load model */
   lman = vdm_LManBegin ();
   vdm_LManSetObject (lman,VDM_DATAFUN,datafun);
   vdm_LManLoadModel (lman,model);
   if(vdm_LManError(lman)) {
      fprintf(stderr,"Error: Unable to load model information\n");
      exit(1);
   }
                   /* close library device and delete interface */
   vdm_DataFunClose (datafun);
   vdm_DataFunEnd (datafun);
   if(filetype == VDM_NASTRAN_BULKDATA) {
      vdm_NASFilEnd (nasfil);
   } else if(filetype == VDM_NASTRAN_OUTPUT2) {
      vdm_NASLibEnd (naslib);
   } else if(filetype == VDM_NATIVE) {
      vdm_NatLibEnd (natlib);
   } else if(filetype == VDM_PAM_INPUT) {
      vdm_PAMFilEnd (pamfil);
   } else if(filetype == VDM_ABAQUS_INPUT) {
      vdm_ABAFilEnd (abafil);
   } else if(filetype == VDM_ABAQUS_FIL) {
      vdm_ABALibEnd (abalib);
   } else if(filetype == VDM_ABAQUS_ODB) {
      vdm_ABALibEnd (abalib);
   } else if(filetype == VDM_ANSYS_INPUT) {
      vdm_ANSFilEnd (ansfil);
   } else if(filetype == VDM_ANSYS_RESULT) {
      vdm_ANSLibEnd (anslib);
   } else if(filetype == VDM_LSTC_INPUT) {
      vdm_D3DFilEnd (d3dfil);
   } else if(filetype == VDM_LSTC_STATE) {
      vdm_D3DLibEnd (d3dlib);
   } else if(filetype == VDM_MECHANICA_STUDY) {
      vdm_RASLibEnd (raslib);
   } else if(filetype == VDM_SDRC_UNIVERSAL) {
      vdm_SDRCLibEnd (sdrclib);
   } else if(filetype == VDM_PATRAN_NEUTRAL) {
      vdm_PatLibEnd (patlib);
   } else if(filetype == VDM_CGNS) {
      vdm_CGNSVLibEnd (cgnsvlib);
   } else if(filetype == VDM_FLUENT_MESH) {
      vdm_FLUENTLibEnd (fluentlib);
   } else if(filetype == VDM_MARC_POST) {
      vdm_MarcLibEnd (marclib);
   }
   vdm_LManEnd (lman);

                   /* traverse Model object */ 
                   /* global properties */
   vis_ModelGetObject (model,VIS_GPROP,(Vobject**)&gprop);
   if(gprop != NULL) {
      printGProp (gprop);
   }
                   /* get Connect object and print nodes and elements */ 
   vis_ModelGetObject (model,VIS_CONNECT,(Vobject**)&connect);
   if(connect != NULL) {
      printConnect (connect);
   }
                   /* node sets */ 
   vis_ModelGetHashTable (model,VIS_IDTRAN_NODE,&nsethash);
   if(nsethash != NULL) {
      printIdTran (nsethash);
   }
                   /* element sets */ 
   vis_ModelGetHashTable (model,VIS_IDTRAN_ELEM,&esethash);
   if(esethash != NULL) {
      printIdTran (esethash);
   }
                   /* element entity sets */ 
   vis_ModelGetHashTable (model,VIS_IDTRAN_ELEMENT,&eenthash);
   if(eenthash != NULL) {
      printIdTran (eenthash);
   }
                   /* coordinate systems */
   vis_ModelGetHashTable (model,VIS_COORDSYS,&coordsyshash);
   if(coordsyshash != NULL) {
      printCoordSys (coordsyshash);
   }
                   /* units */
   vis_ModelGetObject (model,VIS_UNITS,(Vobject**)&units);
   if(units != NULL) {
      printUnits (units);
   }
                   /* element properties */
   vis_ModelGetHashTable (model,VIS_EPROP,&eprophash);
   if(eprophash != NULL) {
      printEProp (eprophash);
   }
                   /* material properties */
   vis_ModelGetHashTable (model,VIS_MPROP,&mprophash);
   if(mprophash != NULL) {
      printMProp (mprophash);
   }
                   /* tabular functions */
   vis_ModelGetHashTable (model,VIS_TCURVE,&tcurvehash);
   if(tcurvehash != NULL) {
      printTCurve (tcurvehash);
   }
                   /* element data */
   vis_ModelGetHashTable (model,VIS_ELEMDAT,&elemdathash);
   if(elemdathash != NULL) {
      printElemDat (elemdathash,connect);
   }
                   /* load cases */
   vis_ModelGetHashTable (model,VIS_LCASE,&lcasehash);
   if(lcasehash != NULL) {
      printLCase (lcasehash,connect);
   }
                   /* restraint cases */
   vis_ModelGetHashTable (model,VIS_RCASE,&rcasehash);
   if(rcasehash != NULL) {
      printRCase (rcasehash,connect);
   }
                   /* multipoint constraint cases */
   vis_ModelGetHashTable (model,VIS_MCASE,&mcasehash);
   if(mcasehash != NULL) {
      printMCase (mcasehash,connect);
   }
                   /* contact pairs */
   vis_ModelGetHashTable (model,VIS_CPAIR,&cpairhash);
   if(cpairhash != NULL) {
      printCPair (cpairhash,connect);
   }
                   /* analytic surfaces */
   vis_ModelGetHashTable (model,VIS_ASURF,&asurfhash);
   if(asurfhash != NULL) {
      printASurf (asurfhash,connect);
   }
                   /* solution properties */
   vis_ModelGetList (model,VIS_SPROP,&sproplist);
   if(sproplist != NULL) {
      printSProp (sproplist);
   }
                   /* delete objects registered in Model */
   vis_ModelDelete (model);
                   /* destroy Model object itself */
   vis_ModelEnd (model);
   return 0;
}

/*----------------------------------------------------------------------
                      print nodes and elements
----------------------------------------------------------------------*/
static void
printConnect(vis_Connect *connect)
{
   Vint i, j, k;
   Vint numnp, numel;
   Vint nid, cid;
   Vint eid, pid, mid, partid;
   Vint featype;
   Vchar extname[9];
   Vdouble x[3];
   Vint maxelemnode;
   Vint nix, *ix, *ux;
   Vint shape, maxi, maxj, maxk;
   Vint nfaces;
   Vint numpartname;
   Vchar partname[256];
   Vint numpartijk, ijk[3];

   vis_ConnectNumber (connect,SYS_NODE,&numnp);
   vis_ConnectNumber (connect,SYS_ELEM,&numel);
   printf("\n");
   printf("Number of nodes=    %d\n",numnp);
   printf("Number of elements= %d\n",numel);
                   /* nodes: coordinates, user id and
                      displacement coordinate system id */
   printf("\nNodes\n");
   for(i = 1; i <= numnp; i++) {
      vis_ConnectCoordsdv (connect,1,&i,(Vdouble(*)[3])x);
      vis_ConnectNodeAssoc (connect,VIS_USERID,1,&i,&nid);
      vis_ConnectNodeAssoc (connect,VIS_CSYSID,1,&i,&cid);
      printf("id= %d, cid= %d, x= %e %e %e\n",nid,cid,x[0],x[1],x[2]);
                   /* check for scalar node */ 
      vis_ConnectNodeAssoc (connect,VIS_FEATYPE,1,&i,&featype);
      if(featype == SYS_NODE_SCALAR) {
         printf("featype= Scalar node\n");
      }
   }
                   /* elements: connectivity, user id, material and 
                      property id, etc. */
   printf("\nElements\n");
   vis_ConnectMaxElemNode (connect,&maxelemnode);
                   /* allocate vectors for internal node ids and user ids */
   ix = (Vint*)malloc(maxelemnode*sizeof(Vint));
   ux = (Vint*)malloc(maxelemnode*sizeof(Vint));
   for(i = 1; i <= numel; i++) {
      vis_ConnectTopology (connect,i,&shape,&maxi,&maxj,&maxk);
      vis_ConnectElemNode (connect,i,&nix,ix);
      vis_ConnectElemAssoc (connect,VIS_USERID,1,&i,&eid);
      vis_ConnectElemAssoc (connect,VIS_PARTID,1,&i,&partid);
      vis_ConnectElemAssoc (connect,VIS_PROPID,1,&i,&pid);
      vis_ConnectElemAssoc (connect,VIS_MATLID,1,&i,&mid);
      vis_ConnectElemAssoc (connect,VIS_CSYSID,1,&i,&cid);
      vis_ConnectElemAssoc (connect,VIS_FEATYPE,1,&i,&featype);
      printf("id= %d, partid= %d, pid= %d, mid= %d, cid= %d, nodes= %d\n",
              eid,partid,pid,mid,cid,nix);
                   /* interpret shape */ 
      if(shape == SYS_SHAPEPOINT) {
         printf(" shape= Point(s):");
      } else if(shape == SYS_SHAPELINE) {
         printf(" shape= Line:");
      } else if(shape == SYS_SHAPETRI) {
         printf(" shape= Triangle:");
      } else if(shape == SYS_SHAPEQUAD) {
         printf(" shape= Quadrilateral:");
      } else if(shape == SYS_SHAPETET) {
         printf(" shape= Tetrahedron:");
      } else if(shape == SYS_SHAPEPYR) {
         printf(" shape= Pyramid:");
      } else if(shape == SYS_SHAPEWED) {
         printf(" shape= Pentahedron:");
      } else if(shape == SYS_SHAPEHEX) {
         printf(" shape= Hexahedron:");
      } else if(shape == SYS_SHAPEPOLYGON) {
         printf(" shape= Polygon:");
      } else if(shape == SYS_SHAPEPOLYHED) {
         printf(" shape= Polyhedron:");
      }
      printf("  maxi= %d, maxj= %d, maxk= %d\n",maxi,maxj,maxk);
                   /* interpret featype */ 
      if(featype == SYS_ELEM_SOLID) {
         printf(" featype= Solid\n");
      } else if(featype == SYS_ELEM_SHELL) {
         printf(" featype= Shell\n");
      } else if(featype == SYS_ELEM_MEMBRANE) {
         printf(" featype= Membrane\n");
      } else if(featype == SYS_ELEM_BEAM) {
         printf(" featype= Beam\n");
      } else if(featype == SYS_ELEM_TRUSS) {
         printf(" featype= Truss\n");
      } else if(featype == SYS_ELEM_GAP) {
         printf(" featype= Gap\n");
      } else if(featype == SYS_ELEM_SPRINGDASHPOT) {
         printf(" featype= Spring Dashpot\n");
      } else if(featype == SYS_ELEM_RIGID) {
         printf(" featype= Rigid\n");
      } else if(featype == SYS_ELEM_CONSTRAINT) {
         printf(" featype= Constraint\n");
      } else if(featype == SYS_ELEM_PLOT) {
         printf(" featype= Plot\n");
      } else if(featype == SYS_ELEM_MASS) {
         printf(" featype= Mass\n");
      } else if(featype == SYS_ELEM_INTER) {
         printf(" featype= Interface\n");
      }
                   /* get external name */ 
      vis_ConnectElemAssoc (connect,VIS_EXTNAMEA,1,&i,(Vint*)extname);
      vis_ConnectElemAssoc (connect,VIS_EXTNAMEB,1,&i,(Vint*)&extname[4]);
      extname[8] = '\0';
      printf(" extname= %s\n",extname);
                   /* convert internal index to user id */ 
      vis_ConnectNodeAssoc (connect,VIS_USERID,nix,ix,ux);
                   /* print element connectivity */ 
      printf(" connectivity=");
      for(j = 0; j < nix; j++) {
         printf(" %d",ux[j]);
      }
      printf("\n");
                   /* print element face connectivity */ 
      vis_ConnectElemNum (connect,SYS_FACE,i,&nfaces);
      printf(" number of faces= %d\n",nfaces);
      for(k = 1; k <= nfaces; k++) {
         vis_ConnectElemCon (connect,SYS_FACE,i,k,&nix,ix);
         vis_ConnectElemTopo (connect,SYS_FACE,i,k,&shape,&maxi,&maxj);
         printf(" face= %d\n",k);
         if(shape == SYS_SHAPETRI) {
            printf("   shape= Triangle:");
         } else if(shape == SYS_SHAPEQUAD) {
            printf("   shape= Quadrilateral:");
         } else if(shape == SYS_SHAPEPOLYGON) {
            printf(" shape= Polygon:");
         }
         printf("  maxi= %d, maxj= %d\n",maxi,maxj);
                   /* convert internal index to user id */ 
         vis_ConnectNodeAssoc (connect,VIS_USERID,nix,ix,ux);
         printf("   connectivity=");
         for(j = 0; j < nix; j++) {
            printf(" %d",ux[j]);
         }
         printf("\n");
      }
   }
                   /* list part names */
   vis_ConnectNumPartName (connect,&numpartname);
   for(i = 1; i <= numpartname; i++) {
      vis_ConnectIthPartName (connect,i,&partid,partname);
      printf("partid= %d, partname= %s\n",partid,partname);
   }
                   /* list part ijk structure */
   vis_ConnectNumPartIJK (connect,&numpartijk);
   for(i = 1; i <= numpartijk; i++) {
      vis_ConnectIthPartIJK (connect,i,&partid,ijk);
      printf("partid= %d, partijk= %d %d %d\n",partid,ijk[0],ijk[1],ijk[2]);
   }
   
                   /* free vectors */ 
   free(ix);
   free(ux);
}

/*----------------------------------------------------------------------
                      print uprop
----------------------------------------------------------------------*/
static void
printUProp(vis_UProp *uprop)
{
   Vint i, j;
   Vint num, nval, dtype;
   Vchar name[256];
   Vchar cval[256];
   Vfloat fval[16];
   Vint ival[16];

   vis_UPropNum (uprop,&num);
   printf("number of user properties= %d\n",num);
   for(i = 1; i <= num; i++) {
      vis_UPropGetType (uprop,i,name,&nval,&dtype);
      printf("property= %d\n",i);
      printf(" name= %s\n",name);
      printf(" nval= %d\n",nval);
      printf(" dtype= %d\n",dtype);
      if(dtype == SYS_INTEGER) {
         vis_UPropValueInteger (uprop,i,ival);
         for(j = 0; j < nval; j++) {
            printf(" ival= %d\n",ival[j]);
         }
      } else if(dtype == SYS_FLOAT) {
         vis_UPropValueFloat (uprop,i,fval);
         for(j = 0; j < nval; j++) {
            printf(" fval= %e\n",fval[j]);
         }
      } else if(dtype == SYS_CHAR) {
         vis_UPropValueString (uprop,i,cval);
         printf(" cval= %s\n",cval);
      }
   }
}

/*----------------------------------------------------------------------
                      print set
----------------------------------------------------------------------*/
static void
printIdTran(vsy_HashTable *nehash)
{
   Vint i;
   Vint iset;
   Vint nument;
   Vint id, no;
   vis_IdTran *idtran;
   vis_UProp *uprop;
   Vint enttype, subtype;
   Vint type, spec;
   Vchar name[256];

   vsy_HashTableInitIter (nehash);
   while(vsy_HashTableNextIter(nehash,&iset,(Vobject**)&idtran),idtran) {
                   /* print set name, etc. */ 
      vis_IdTranGetEntType (idtran,&enttype,&subtype);
      vis_IdTranGetName (idtran,name);
      if(enttype == SYS_NODE && subtype == SYS_NONE) {
         printf("\nNode Set, iset= %d, Name= %s\n",iset,name);
      } else if(enttype == SYS_ELEM && subtype == SYS_NONE) {
         printf("\nElement Set, iset= %d, Name= %s\n",iset,name);
      } else if(enttype == SYS_ELEM && subtype == SYS_EDGE) {
         printf("\nElement Edge Set, iset= %d, Name= %s\n",iset,name);
      } else if(enttype == SYS_ELEM && subtype == SYS_FACE) {
         printf("\nElement Face Set, iset= %d, Name= %s\n",iset,name);
      }
                   /* print type and spec */ 
      vis_IdTranGetType (idtran,&type);
      vis_IdTranGetSpec (idtran,&spec);
      printf("type= %d, spec= %d\n",type,spec);
                   /* print possible user defined data */
      vis_IdTranGetUProp (idtran,&uprop);
      if(uprop) {
         printUProp (uprop);
      }
                   /* print entity indices in set */ 
                   /* note, these are not the node or element user id */ 
      vis_IdTranInq (idtran,&nument);
      for(i = 1; i <= nument; i++) {
         vis_IdTranGetId (idtran,i,&id);
         if(subtype == SYS_NONE) {
            printf("id= %d\n",id);
         } else {
            vis_IdTranGetEnt (idtran,i,&no);
            printf("id= %d, no= %d\n",id,no);
         }
      }
   }
}

/*----------------------------------------------------------------------
                      print coordinate systems
----------------------------------------------------------------------*/
static void
printCoordSys(vsy_HashTable *cshash)
{
   vis_CoordSys *coordsys;
   Vint id;
   Vint type;
   Vdouble x[3], tm[3][3];

   printf("\nCoordinate Systems\n");
   vsy_HashTableInitIter (cshash);
   while(vsy_HashTableNextIter(cshash,&id,(Vobject**)&coordsys),coordsys) {
      printf("id= %d, type= ",id);
      vis_CoordSysInq (coordsys,&type);
      if(type == SYS_CARTESIAN) {
         printf(" Cartesian\n");
      } else if(type == SYS_CYLINDRICAL) {
         printf(" Cylindrical\n");
      } else if(type == SYS_SPHERICAL) {
         printf(" Spherical\n");
      } else if(type == SYS_SPHERICAL_ALT) {
         printf(" Spherical Alternate\n");
      } else if(type == SYS_TOROIDAL) {
         printf(" Toroidal\n");
      } else if(type == SYS_CYLINDRICAL_ALT) {
         printf(" Cylindrical Alternate\n");
      }
      vis_CoordSysOriginTriaddv (coordsys,x,tm);
      printf(" origin= %e %e %e\n",x[0],x[1],x[2]);
      printf(" dircos= %e %e %e\n",tm[0][0],tm[1][0],tm[2][0]);
      printf("         %e %e %e\n",tm[0][1],tm[1][1],tm[2][1]);
      printf("         %e %e %e\n",tm[0][2],tm[1][2],tm[2][2]);
   }
}

/*----------------------------------------------------------------------
                      print global properties
----------------------------------------------------------------------*/
static void
printGProp(vis_GProp *gprop)
{
   Vint i;
   Vint flag;
   Vint iparams[2];
   Vfloat fparams[3];
   Vdouble dparams[3];
   Vchar cparams[81];
   Vint user_num, user_ith, userdimenum, userdime, userdatatype;
   Vint symmnum, *isymm;

   printf("\nGProp\n");

   vis_GPropValueFlag (gprop,GPROP_TITLE,&flag);
   if(flag) {
      vis_GPropValueString (gprop,GPROP_TITLE,cparams);
      printf("TITLE: %s\n",cparams);
   }
   vis_GPropValueFlag (gprop,GPROP_SUBTITLE,&flag);
   if(flag) {
      vis_GPropValueString (gprop,GPROP_SUBTITLE,cparams);
      printf("SUBTITLE: %s\n",cparams);
   }
   vis_GPropValueFlag (gprop,GPROP_2DPLANE,&flag);
   if(flag) {
      vis_GPropValueInteger (gprop,GPROP_2DPLANE,iparams);
      printf("2DPLANE: %d\n",iparams[0]);
   }
   vis_GPropValueFlag (gprop,GPROP_2DTYPE,&flag);
   if(flag) {
      vis_GPropValueInteger (gprop,GPROP_2DTYPE,iparams);
      printf("2DTYPE: %d\n",iparams[0]);
   }
                   /* cyclic symmetry information */ 
   vis_GPropValueFlag (gprop,GPROP_CYCLIC_NSEC,&flag);
   if(flag) {
      vis_GPropValueInteger (gprop,GPROP_CYCLIC_NSEC,iparams);
      printf("CYCLIC_NSEC: %d\n",iparams[0]);
   }
   vis_GPropValueFlag (gprop,GPROP_CYCLIC_ORIG,&flag);
   if(flag) {
      vis_GPropValueFloat (gprop,GPROP_CYCLIC_ORIG,fparams);
      printf("CYCLIC_ORIG: %e %e %e\n",fparams[0],fparams[1],fparams[2]);
   }
   vis_GPropValueFlag (gprop,GPROP_CYCLIC_AXIS,&flag);
   if(flag) {
      vis_GPropValueFloat (gprop,GPROP_CYCLIC_AXIS,fparams);
      printf("CYCLIC_AXIS: %e %e %e\n",fparams[0],fparams[1],fparams[2]);
   }
                   /* generalized symmetry set information */ 
   vis_GPropValueFlag (gprop,GPROP_SYMM_NUM,&flag);
   if(flag) {
      vis_GPropValueInteger (gprop,GPROP_SYMM_NUM,&symmnum);
      printf("SYMM_NUM: %d\n",symmnum);
      isymm = (Vint*)malloc(symmnum*sizeof(Vint));
      vis_GPropValueFlag (gprop,GPROP_SYMM_ID,&flag);
      if(flag) {
         vis_GPropValueInteger (gprop,GPROP_SYMM_ID,isymm);
         printf("SYMM_ID:");
         for(i = 0; i < symmnum; i++) {
            printf(" %d",isymm[i]);
         }
         printf("\n");
      }
      vis_GPropValueFlag (gprop,GPROP_SYMM_NSEC,&flag);
      if(flag) {
         vis_GPropValueInteger (gprop,GPROP_SYMM_NSEC,isymm);
         printf("SYMM_NSEC:");
         for(i = 0; i < symmnum; i++) {
            printf(" %d",isymm[i]);
         }
         printf("\n");
      }
      free(isymm);
                   /* other GPROP_SYMM_XXX are similar */ 
   }
                   /* user defined scalar values */ 
   vis_GPropValueFlag (gprop,GPROP_USER_NUM,&flag);
   if(flag) {
      vis_GPropValueInteger (gprop,GPROP_USER_NUM,&user_num);
      for(user_ith = 0; user_ith < user_num; user_ith++) {
         vis_GPropValueInteger (gprop,GPROP_USERDIMENUM+user_ith,&userdimenum);
         if(userdimenum > 1)  continue;
         vis_GPropValueInteger (gprop,GPROP_USERDIME+user_ith,&userdime);
         if(userdime > 1)  continue;
         vis_GPropValueString (gprop,GPROP_USERNAME+user_ith,cparams);
         printf("user name= %s\n",cparams);
         vis_GPropValueInteger (gprop,GPROP_USERDATATYPE+user_ith,&userdatatype);
         if(userdatatype == SYS_INTEGER) {
            vis_GPropValueInteger (gprop,GPROP_USERDATA+user_ith,iparams);
            printf("user data= %d\n",iparams[0]);
         } else if(userdatatype == SYS_DOUBLE || userdatatype == SYS_FLOAT) {
            vis_GPropValueDouble (gprop,GPROP_USERDATA+user_ith,dparams);
            printf("user data= %le\n",dparams[0]);
         }
      }
   }
}

/*----------------------------------------------------------------------
                      print units
----------------------------------------------------------------------*/
static void
printUnits(vis_Units *units)
{
   Vint length, mass, time, temp, angle, charge;
   Vint clength, cmass, ctime, ctemp, cangle, ccharge;
   Vdouble lengthfac, massfac, timefac, tempfac, tempoff, anglefac, chargefac;
   Vchar cstg[33];

   printf("\nUnits\n");
                   /* get basic unit types */ 
   vis_UnitsGetBase (units,UNITS_LENGTH,&length);
   vis_UnitsGetBase (units,UNITS_MASS,&mass);
   vis_UnitsGetBase (units,UNITS_TIME,&time);
   vis_UnitsGetBase (units,UNITS_TEMP,&temp);
   vis_UnitsGetBase (units,UNITS_ANGLE,&angle);
   vis_UnitsGetBase (units,UNITS_CHARGE,&charge);

                   /* print */
   vis_UnitsGetDesc (units,UNITS_LENGTH,length,cstg);
   printf("length type= %d, %s\n",length,cstg);
   vis_UnitsGetDesc (units,UNITS_MASS,mass,cstg);
   printf("mass type=  %d, %s\n",mass,cstg);
   vis_UnitsGetDesc (units,UNITS_TIME,time,cstg);
   printf("time type=  %d, %s\n",time,cstg);
   vis_UnitsGetDesc (units,UNITS_TEMP,temp,cstg);
   printf("temp type=  %d, %s\n",temp,cstg);
   vis_UnitsGetDesc (units,UNITS_ANGLE,angle,cstg);
   printf("angle type= %d, %s\n",angle,cstg);
   vis_UnitsGetDesc (units,UNITS_CHARGE,charge,cstg);
   printf("charge type= %d, %s\n",charge,cstg);

                   /* get conversion unit types */ 
   vis_UnitsGetConv (units,UNITS_LENGTH,&clength);
   vis_UnitsGetConv (units,UNITS_MASS,&cmass);
   vis_UnitsGetConv (units,UNITS_TIME,&ctime);
   vis_UnitsGetConv (units,UNITS_TEMP,&ctemp);
   vis_UnitsGetConv (units,UNITS_ANGLE,&cangle);
   vis_UnitsGetConv (units,UNITS_CHARGE,&ccharge);
                   /* print all generically */
   printf("length type= %d\n",clength);
   printf("mass type=   %d\n",cmass);
   printf("time type=   %d\n",ctime);
   printf("temp type=   %d\n",ctemp);
   printf("angle type=  %d\n",cangle);
   printf("charge type= %d\n",ccharge);

                   /* get conversion unit factors, offset */ 
   vis_UnitsGetFactor (units,UNITS_LENGTH,&lengthfac);
   vis_UnitsGetFactor (units,UNITS_MASS,&massfac);
   vis_UnitsGetFactor (units,UNITS_TIME,&timefac);
   vis_UnitsGetFactor (units,UNITS_TEMP,&tempfac);
   vis_UnitsGetFactor (units,UNITS_TEMP_OFFSET,&tempoff);
   vis_UnitsGetFactor (units,UNITS_ANGLE,&anglefac);
   vis_UnitsGetFactor (units,UNITS_CHARGE,&chargefac);
                   /* print */
   printf("length factor= %e\n",lengthfac);
   printf("mass factor=   %e\n",massfac);
   printf("time factor=   %e\n",timefac);
   printf("temp factor=   %e\n",tempfac);
   printf("temp offset=   %e\n",tempoff);
   printf("angle factor=  %e\n",anglefac);
   printf("charge factor= %e\n",chargefac);
}

/*----------------------------------------------------------------------
                      print element properties
----------------------------------------------------------------------*/
static void
printEProp(vsy_HashTable *ephash)
{
   Vint i, j, k;
   vis_EProp *eprop;
   Vint id;
   Vint eptype;
   Vint ntypes, *type;
   Vint flag, nval, nloc, dtyp;
   Vchar ename[256], name[64];
   Vint iparams[100];
   Vdouble dparams[100];
   Vchar cval[256];

   printf("\nElement Properties\n");
   vsy_HashTableInitIter (ephash);
   while(vsy_HashTableNextIter(ephash,&id,(Vobject**)&eprop),eprop) {
      printf("id= %d, type= ",id);
      vis_EPropInq (eprop,&eptype);
      if(eptype == SYS_ELEM_SOLID) {
         printf(" Solid Property\n");
      } else if(eptype == SYS_ELEM_SHELL) {
         printf(" Shell Property\n");
      } else if(eptype == SYS_ELEM_MEMBRANE) {
         printf(" Membrane Property\n");
      } else if(eptype == SYS_ELEM_BEAM) {
         printf(" Beam Property\n");
      } else if(eptype == SYS_ELEM_TRUSS) {
         printf(" Truss Property\n");
      } else if(eptype == VIS_ELEM_SPRINGDASHPOT) {
         printf(" Spring Dashpot Property\n");
      } else if(eptype == SYS_ELEM_RIGID) {
         printf(" Rigid Property\n");
      } else if(eptype == SYS_ELEM_MASS) {
         printf(" Mass Property\n");
      }
      vis_EPropGetName (eprop,ename);
      if(ename[0] != '\0') {
         printf("name= %s",ename);
      }
      vis_EPropValueTypeNum (eprop,&ntypes);
      type = (Vint*)malloc(ntypes*sizeof(Vint));
      vis_EPropValueType (eprop,&ntypes,type);

                   /* loop through types generically */ 
      for(i = 0; i < ntypes; i++) {
         vis_EPropValueName (eprop,type[i],name);
         printf("\n name= %s\n",name);
         vis_EPropValueFlag (eprop,type[i],&flag);
         if(flag == EPROP_UNDEFINED) {
            printf("Undefined\n");
         } else {
            vis_EPropValueParams (eprop,type[i],&nval,&nloc,&dtyp);
            printf(" nval= %d, nloc= %d\n",nval,nloc);
                   /* check for too many values for array size */ 
            if(nval*nloc > 100)  continue;
                   /* integer valued */ 
            if(dtyp == SYS_INTEGER) {
               printf(" Integer\n");
               vis_EPropValueInteger (eprop,type[i],iparams);
               for(k = 0; k < nloc; k++) {
                  if(nloc > 1) printf(" Location= %d\n",k);
                  for(j = 0; j < nval; j++) {
                     printf("  value= %d\n",iparams[k*nval+j]);
                  }
               }
                   /* real valued */ 
            } else if(dtyp == SYS_REAL) {
               vis_EPropValueDouble (eprop,type[i],dparams);
               printf(" Real\n");
               for(k = 0; k < nloc; k++) {
                  if(nloc > 1) printf(" Location= %d\n",k);
                  for(j = 0; j < nval; j++) {
                     printf("  value= %e\n",dparams[k*nval+j]);
                  }
               }
                   /* character valued */
            } else if(dtyp == SYS_CHAR) {
               vis_EPropValueString (eprop,type[i],cval);
               printf(" Character\n");
               printf("  value= %s\n",cval);
            }
         }
      }
      free(type);
   }
}

/*----------------------------------------------------------------------
                      print material properties
----------------------------------------------------------------------*/
static void
printMProp(vsy_HashTable *mphash)
{
   Vint i, j;
   vis_MProp *mprop;
   Vint id;
   Vint mptype;
   Vint ntypes, *type;
   Vint flag, nval, dtyp;
   Vchar mname[256], name[64];
   Vint iparams[100];
   Vdouble dparams[100];
   Vint tid;

   printf("\nMaterial Properties\n");
   vsy_HashTableInitIter (mphash);
   while(vsy_HashTableNextIter(mphash,&id,(Vobject**)&mprop),mprop) {
      printf("id= %d, type= ",id);
      vis_MPropInq (mprop,&mptype);
      if(mptype == SYS_MAT_ISOTROPIC) {
         printf(" Isotropic Property\n");
      } else if(mptype == SYS_MAT_ORTHOTROPIC) {
         printf(" Orthotropic Property\n");
      } else if(mptype == SYS_MAT_ANISOTROPIC) {
         printf(" Anisotropic Property\n");
      }
      vis_MPropGetName (mprop,mname);
      if(mname[0] != '\0') {
         printf("name= %s",mname);
      }
      vis_MPropValueTypeNum (mprop,&ntypes);
      type = (Vint*)malloc(ntypes*sizeof(Vint));
      vis_MPropValueType (mprop,&ntypes,type);

                   /* loop through types */
      for(i = 0; i < ntypes; i++) {
         vis_MPropValueName (mprop,type[i],name);
         printf("\n name = %s\n",name);
         vis_MPropValueFlag (mprop,type[i],&flag);
         if(flag == MPROP_UNDEFINED) {
            printf("Undefined\n");
         } else if(flag == MPROP_VALUE) {
            vis_MPropValueParams (mprop,type[i],&nval,&dtyp);
            printf(" nval= %d\n",nval);
                   /* check for too many values for array size */ 
            if(nval > 100)  continue;
                   /* integer valued */
            if(dtyp == SYS_INTEGER) {
               printf(" Integer\n");
               vis_MPropValueInteger (mprop,type[i],iparams);
               for(j = 0; j < nval; j++) {
                  printf("  value= %d\n",iparams[j]);
               }
                   /* real valued */
            } else if(dtyp == SYS_REAL) {
               vis_MPropValueDouble (mprop,type[i],dparams);
               printf(" Real\n");
               for(j = 0; j < nval; j++) {
                  printf("  value= %e\n",dparams[j]);
               }
            }
         } else if(flag == MPROP_IDENTIFIER) {
            vis_MPropValueId (mprop,type[i],&tid);
            printf(" TCurve identifier= %d\n",tid);
         }
      }
      free(type);
   }
}

/*----------------------------------------------------------------------
                      print tabular functions
----------------------------------------------------------------------*/
static void
printTCurve(vsy_HashTable *tchash)
{
   Vint i, j;
   vis_TCurve *tcurve;
   Vint id;
   Vint tctype, nval, npts;
   Vdouble t, val[100];

   printf("\nTabular Funtions\n");
   vsy_HashTableInitIter (tchash);
   while(vsy_HashTableNextIter(tchash,&id,(Vobject**)&tcurve),tcurve) {
      vis_TCurveInq (tcurve,&tctype,&nval);
      printf("id= %d, nval= %d, type= ",id,nval);
                   /* check for too many values for array size */ 
      if(nval > 100)  continue;
      if(tctype == TCURVE_PWLINEAR) {
         printf(" Piecewise Linear Function\n");
      }
                   /* print function values */ 
      vis_TCurveNum (tcurve,&npts);
      printf("npts= %d\n",npts);
                   /* loop through points one at a time */
      for(i = 1; i <= npts; i++) {
         vis_TCurveIndepdv (tcurve,1,&i,&t);
         printf("point= %d, t= %e, v= ",i,t);
                   /* evaluate function at this point */ 
         vis_TCurveEvaldv (tcurve,1,&t,val);
         for(j = 0; j < nval; j++) {
            printf(" %e",val[j]);
         }
         printf("\n");
      }
   }
}

/*----------------------------------------------------------------------
                      print element data
----------------------------------------------------------------------*/
static void
printElemDat(vsy_HashTable *edhash, vis_Connect *connect)
{
   Vint i, j;
   vis_ElemDat *elemdat;
   Vint id;
   Vint iprop;
   Vint numel;
   Vint flags;
   Vdouble thk[9], vec[9][3], fib[9];
   Vint nix, ix[9], ux[9];
   Vint nument, enttype, subtype, datatype;

   vis_ConnectNumber (connect,SYS_ELEM,&numel);

   printf("\nElement Data\n");
   vsy_HashTableInitIter (edhash);
   while(vsy_HashTableNextIter(edhash,&iprop,(Vobject**)&elemdat),elemdat) {
      vis_ElemDatInq (elemdat,&nument,&enttype,&subtype,&datatype);
                   /* element thickness, surface elements */ 
      if(iprop == SYS_PROP_THICKNESS) {
         printf("\nElement Thicknesses\n");
         for(i = 1; i <= numel; i++) {
            vis_ElemDatDataStat (elemdat,i,1,&flags);
            if(flags == 0)  continue;
            vis_ConnectElemAssoc (connect,VIS_USERID,1,&i,&id);
            printf("elem= %d\n",id);
            vis_ElemDatDatadv (elemdat,i,1,thk);
            if(subtype == SYS_NONE) {
               printf(" thickness= %e\n",thk[0]);
            } else {
               vis_ConnectElemNode (connect,i,&nix,ix);
               vis_ConnectNodeAssoc (connect,VIS_USERID,nix,ix,ux);
               for(j = 0; j < nix; j++) {
                  printf(" node= %d, thickness= %e\n",ux[j],thk[j]);
               }
            }
         }
                   /* element offset vectors */ 
      } else if(iprop == SYS_PROP_OFFSETVEC) {
         printf("\nElement Offset Vectors\n");
         for(i = 1; i <= numel; i++) {
            vis_ElemDatDataStat (elemdat,i,1,&flags);
            if(flags == 0)  continue;
            vis_ConnectElemAssoc (connect,VIS_USERID,1,&i,&id);
            printf("elem= %d\n",id);
            vis_ElemDatDatadv (elemdat,i,1,(Vdouble*)vec);
            if(subtype == SYS_NONE) {
               printf(" offset vector= %e %e %e\n",
                        vec[0][0],vec[0][1],vec[0][2]);
            } else {
               vis_ConnectElemNode (connect,i,&nix,ix);
               vis_ConnectNodeAssoc (connect,VIS_USERID,nix,ix,ux);
               for(j = 0; j < nix; j++) {
                  printf(" node= %d, offset vector= %e %e %e\n",
                           ux[j],vec[j][0],vec[j][1],vec[j][2]);
               }
            }
         }
                   /* element orientation vectors */ 
      } else if(iprop == SYS_PROP_ELEMVEC) {
         printf("\nElement Orientation Vectors\n");
         for(i = 1; i <= numel; i++) {
            vis_ElemDatDataStat (elemdat,i,1,&flags);
            if(flags == 0)  continue;
            vis_ConnectElemAssoc (connect,VIS_USERID,1,&i,&id);
            printf("elem= %d\n",id);
            vis_ElemDatDatadv (elemdat,i,1,(Vdouble*)vec);
            if(subtype == SYS_NONE) {
               printf(" orientation vector= %e %e %e\n",
                        vec[0][0],vec[0][1],vec[0][2]);
            } else {
               vis_ConnectElemNode (connect,i,&nix,ix);
               vis_ConnectNodeAssoc (connect,VIS_USERID,nix,ix,ux);
               for(j = 0; j < nix; j++) {
                  printf(" node= %d, orientation vector= %e %e %e\n",
                           ux[j],vec[j][0],vec[j][1],vec[j][2]);
               }
            }
         }
                   /* element material orientation vectors */ 
      } else if(iprop == SYS_PROP_MATLVEC) {
         printf("\nElement Material Orientation Vectors\n");
                   /* element bottom and top fiber locations */
      } else if(iprop == SYS_PROP_FIBERBOT  ||
                iprop == SYS_PROP_FIBERTOP) {
         printf("\nElement Fiber Locations\n");
         for(i = 1; i <= numel; i++) {
            vis_ElemDatDataStat (elemdat,i,1,&flags);
            if(flags == 0)  continue;
            vis_ConnectElemAssoc (connect,VIS_USERID,1,&i,&id);
            printf("elem= %d\n",id);
            vis_ElemDatDatadv (elemdat,i,1,fib);
            if(subtype == SYS_NONE) {
               if(iprop == SYS_PROP_FIBERBOT) {
                  printf(" fiber (bottom)= %e\n",fib[0]);
               } else {
                  printf(" fiber (top)= %e\n",fib[0]);
               }
            } else {
               vis_ConnectElemNode (connect,i,&nix,ix);
               vis_ConnectNodeAssoc (connect,VIS_USERID,nix,ix,ux);
               for(j = 0; j < nix; j++) {
                  if(iprop == SYS_PROP_FIBERBOT) {
                     printf(" node= %d, fiber (bottom)= %e\n",ux[j],fib[j]);
                  } else {
                     printf(" node= %d, fiber (top)= %e\n",ux[j],fib[j]);
                  }
               }
            }
         }
      }
   }
}

/*----------------------------------------------------------------------
                      print load cases
----------------------------------------------------------------------*/
static void
printLCase(vsy_HashTable *lchash, vis_Connect *connect)
{
   Vint i, j, k;
   vis_LCase *lcase;
   Vint id;
   Vint maxindex;
   Vint flags;
   Vint nface;
   Vint nixf, ixf[9], uxf[9];
   Vdouble v[2*3*9];
   Vdouble grav[3], cent[3], w[3], wdot[3];
   Vint complexflag, complexmode;

   printf("\nLoad Cases\n");
   vsy_HashTableInitIter (lchash);
   while(vsy_HashTableNextIter(lchash,&id,(Vobject**)&lcase),lcase) {
      printf("id= %d\n",id);
                   /* determine if complex data */
      vis_LCaseGetComplex (lcase,&complexflag);
      vis_LCaseGetComplexMode (lcase,&complexmode);
                   /* concentrated forces, illustrate possible complex */ 
      vis_LCaseConcMax (lcase,LCASE_FORCE,&maxindex);
      for(i = 1; i <= maxindex; i++) {
         vis_LCaseConcFlag (lcase,i,LCASE_FORCE,&flags);
         if(flags == 0)  continue;
         vis_ConnectNodeAssoc (connect,VIS_USERID,1,&i,&id);
         if(complexflag) {
            vis_LCaseSetComplexMode (lcase,SYS_COMPLEX_REALIMAGINARY);
            vis_LCaseConcdv (lcase,i,LCASE_FORCE,v);
            printf("node= %d, force vector= %e %e(i) %e %e(i) %e %e(i)\n",
                    id,v[0],v[1],v[2],v[3],v[4],v[5]);
            vis_LCaseSetComplexMode (lcase,complexmode);
         } else {
            vis_LCaseConcdv (lcase,i,LCASE_FORCE,v);
            printf("node= %d, force vector= %e %e %e\n",
                    id,v[0],v[1],v[2]);
         }
      }
                   /* concentrated moments */ 
      vis_LCaseConcMax (lcase,LCASE_MOMENT,&maxindex);
      for(i = 1; i <= maxindex; i++) {
         vis_LCaseConcFlag (lcase,i,LCASE_MOMENT,&flags);
         if(flags == 0)  continue;
         vis_LCaseConcdv (lcase,i,LCASE_MOMENT,v);
         vis_ConnectNodeAssoc (connect,VIS_USERID,1,&i,&id);
         printf("node= %d, moment vector= %e %e %e\n",id,v[0],v[1],v[2]);
      }
                   /* pressure loads */ 
      vis_LCaseDistMax (lcase,SYS_FACE,LCASE_PRES,&maxindex);
      for(i = 1; i <= maxindex; i++) {
         vis_LCaseDistFlag (lcase,SYS_FACE,i,LCASE_PRES,&flags);
         if(flags == 0)  continue;
         vis_ConnectElemAssoc (connect,VIS_USERID,1,&i,&id);
         vis_ConnectElemNum (connect,SYS_FACE,i,&nface);
         for(j = 1; j <= nface; j++) {
            if(VIEW_FLAG(flags,j) == 0) continue;
            vis_LCaseDistdv (lcase,SYS_FACE,i,j,LCASE_PRES,0,v);
            vis_ConnectElemCon (connect,SYS_FACE,i,j,&nixf,ixf);
            vis_ConnectNodeAssoc (connect,VIS_USERID,nixf,ixf,uxf);
            printf("elem= %d, face= %d\n",id,j);
            for(k = 0; k < nixf; k++) {
               printf(" node= %d, pressure= %e\n",uxf[k],v[k]);
            }
         }
      }
                   /* traction loads */ 
      vis_LCaseDistMax (lcase,SYS_FACE,LCASE_TRAC,&maxindex);
      for(i = 1; i <= maxindex; i++) {
         vis_LCaseDistFlag (lcase,SYS_FACE,i,LCASE_TRAC,&flags);
         if(flags == 0)  continue;
         vis_ConnectElemAssoc (connect,VIS_USERID,1,&i,&id);
         vis_ConnectElemNum (connect,SYS_FACE,i,&nface);
         for(j = 1; j <= nface; j++) {
            if(VIEW_FLAG(flags,j) == 0) continue;
            vis_LCaseDistdv (lcase,SYS_FACE,i,j,LCASE_TRAC,0,v);
            vis_ConnectElemCon (connect,SYS_FACE,i,j,&nixf,ixf);
            vis_ConnectNodeAssoc (connect,VIS_USERID,nixf,ixf,uxf);
            printf("elem= %d, face= %d\n",id,j);
            for(k = 0; k < nixf; k++) {
               printf(" node= %d, traction vector= %e %e %e\n",
                        uxf[k],v[3*k],v[3*k+1],v[3*k+2]);
            }
         }
      }
                   /* accelerations */ 
      vis_LCaseAccelFlag (lcase,&flags);
      if(flags) {
         vis_LCaseAcceldv (lcase,grav,cent,w,wdot);
         if(grav[0] != 0. || grav[1] != 0. || grav[2] != 0.) {
            printf(" gravity vector= %e %e %e\n",grav[0],grav[1],grav[2]);
         }
         printf(" center of rotation= %e %e %e\n",cent[0],cent[1],cent[2]);
         if(w[0] != 0. || w[1] != 0. || w[2] != 0.) {
            printf(" angular velocity vector= %e %e %e\n",w[0],w[1],w[2]);
         }
         if(wdot[0] != 0. || wdot[1] != 0. || wdot[2] != 0.) {
            printf(" angular acceleration vector= %e %e %e\n",
                    wdot[0],wdot[1],wdot[2]);
         }
      }
   }
}

/*----------------------------------------------------------------------
                      print restraint cases
----------------------------------------------------------------------*/
static void
printRCase(vsy_HashTable *rchash, vis_Connect *connect)
{
   Vint i, j;
   vis_RCase *rcase;
   Vint id;
   Vint maxindex;
   Vint numtags, tag[SYS_DOF_MAX];
   Vint nid;
   Vint rtype, master;
   Vdouble value;

   printf("\nRestraint Cases\n");
   vsy_HashTableInitIter (rchash);
   while(vsy_HashTableNextIter(rchash,&id,(Vobject**)&rcase),rcase) {
      printf("id= %d\n",id);
      vis_RCaseSPCMax (rcase,&maxindex);
      for(i = 1; i <= maxindex; i++) {
         vis_RCaseSPCTag (rcase,i,&numtags,tag);
         if(numtags == 0)  continue;
         vis_ConnectNodeAssoc (connect,VIS_USERID,1,&i,&nid);
                   /* loop through dof tags */ 
         for(j = 0; j < numtags; j++) {
            vis_RCaseSPCdv (rcase,i,tag[j],&rtype,&value,&master);
            if(rtype == RCASE_FIXED) {
               printf(" node= %d, fixed dof tag= %d\n",nid,tag[j]);
            } else if(rtype == RCASE_APPLIED) {
               printf(" node= %d, applied dof tag= %d, value= %e\n",
                       nid,tag[j],value);
            }
         }
      }
   }
}

/*----------------------------------------------------------------------
                      print multipoint constraint cases
----------------------------------------------------------------------*/
static void
printMCase(vsy_HashTable *mchash, vis_Connect *connect)
{
   Vint i, j;
   vis_MCase *mcase;
   Vint id;
   Vint maxindex, maxterms, maxrhs;
   Vint type, nterms;
   Vint nid;
   Vint *ix, *ig;
   Vdouble *c;
   Vdouble rhs;

   printf("\nMultipoint Constraint Cases\n");
   vsy_HashTableInitIter (mchash);
   while(vsy_HashTableNextIter(mchash,&id,(Vobject**)&mcase),mcase) {
      printf("id= %d\n",id);
      vis_MCaseMax (mcase,&maxindex,&maxterms,&maxrhs);
      ix = (Vint*)malloc(maxterms*sizeof(Vint));
      ig = (Vint*)malloc(maxterms*sizeof(Vint));
      c = (Vdouble*)malloc(maxterms*sizeof(Vdouble));
      for(i = 1; i <= maxindex; i++) {
         vis_MCaseNum (mcase,i,&nterms);
         if(nterms) {
            vis_MCaseType (mcase,i,&type);
                   /* constraint equation */ 
            if(type == MCASE_MPC) {
               vis_MCaseMPCdv (mcase,i,&nterms,ix,ig,c,&rhs);
               printf("index= %d, nterms= %d, rhs= %f\n",i,nterms,rhs);
               for(j = 0; j < nterms; j++) {
                  vis_ConnectNodeAssoc (connect,VIS_USERID,1,&ix[j],&nid);
                  printf(" ix= %d, tag= %d, c= %f\n",nid,ig[j],c[j]);
               }
                   /* constraint node based entity */ 
            } else {
               vis_MCaseCon (mcase,i,&type,&nterms,ix);
               printf("index= %d, type= %d, nterms= %d\n",i,type,nterms);
               for(j = 0; j < nterms; j++) {
                  vis_ConnectNodeAssoc (connect,VIS_USERID,1,&ix[j],&nid);
                  printf(" ix= %d\n",nid);
               }
            }
         }
      }
      free(ix);
      free(ig);
      free(c);
   }
}

/*----------------------------------------------------------------------
                      print contact pairs
----------------------------------------------------------------------*/
static void
printCPair(vsy_HashTable *cphash, vis_Connect *connect)
{
   vis_CPair *cpair;
   Vint id;
   Vint mastent, slavent, ctype;

   printf("\nContact Pairs\n");
   vsy_HashTableInitIter (cphash);
   while(vsy_HashTableNextIter(cphash,&id,(Vobject**)&cpair),cpair) {
      printf("id= %d\n",id);
      vis_CPairInq (cpair,&mastent,&slavent);
      if(mastent == SYS_EDGE) {
         printf(" Master Edge\n");
      } else if(mastent == SYS_FACE) {
         printf(" Master Face\n");
      }
      if(slavent == SYS_NONE) {
         printf(" Slave None\n");
      } else if(slavent == SYS_NODE) {
         printf(" Slave Node\n");
      } else if(slavent == SYS_EDGE) {
         printf(" Slave Edge\n");
      } else if(slavent == SYS_FACE) {
         printf(" Slave Face\n");
      }
      vis_CPairGetType (cpair,&ctype);
      if(ctype == CPAIR_CONTACT) {
         printf(" Contact Pair\n");
      } else if(ctype == CPAIR_COSIM) {
         printf(" Co-simulation Pair\n");
      }
   }
}

/*----------------------------------------------------------------------
                      print analytic surfaces
----------------------------------------------------------------------*/
static void
printASurf(vsy_HashTable *ashash, vis_Connect *connect)
{
   vis_ASurf *asurf;
   Vint id, type;
   Vchar name[64];
   Vdouble x[3], r;
   Vdouble a[3], b[3], c[3], length, width, height, radius;
   Vint numpnt, numseg;

   printf("\nAnalytic Surfaces\n");
   vsy_HashTableInitIter (ashash);
   while(vsy_HashTableNextIter(ashash,&id,(Vobject**)&asurf),asurf) {
      printf("id= %d\n",id);
      vis_ASurfInq (asurf,&type);
      vis_ASurfGetName (asurf,name);
      if(name[0] != '\0') {
         printf("name= %s\n",name);
      }
      if(type == ASURF_SPHERE) {
         vis_ASurfGetSpheredv (asurf,x,&r);
         printf("Sphere, id= %d, x= %f %f %f, r= %f\n",id,x[0],x[1],x[2],r);
      } else if(type == ASURF_CYLINDER) {
         vis_ASurfGetCylinderdv (asurf,a,b,c,&radius,&height);
         printf("Cylinder, id= %d, a= %f %f %f\n",id,a[0],a[1],a[2]);
         printf("                  b= %f %f %f\n",b[0],b[1],b[2]);
         printf("                  c= %f %f %f\n",c[0],c[1],c[2]);
         printf("                  radius= %f\n",radius);
         printf("                  height= %f\n",height);
      } else if(type == ASURF_PLANE) {
         vis_ASurfGetPlanedv (asurf,a,b,c,&length,&width);
         printf("Plane, id= %d, a= %f %f %f\n",id,a[0],a[1],a[2]);
         printf("               b= %f %f %f\n",b[0],b[1],b[2]);
         printf("               c= %f %f %f\n",c[0],c[1],c[2]);
         printf("               length= %f, width= %f\n",length,width);
      } else if(type == ASURF_BOX) {
         vis_ASurfGetBoxdv (asurf,a,b,c,&length,&width,&height);
         printf("Box, id= %d, a= %f %f %f\n",id,a[0],a[1],a[2]);
         printf("             b= %f %f %f\n",b[0],b[1],b[2]);
         printf("             c= %f %f %f\n",c[0],c[1],c[2]);
         printf("             length= %f, width= %f, height= %f\n",
                              length,width,height);
      } else if(type == ASURF_SEGMENT) {
         vis_ASurfNumPoints (asurf,&numpnt);
         vis_ASurfNumSegments (asurf,&numseg);
         printf("Segment, id= %d, numpnts= %d, numseg= %d\n",
                          id,numpnt,numseg);
      } else if(type == ASURF_SEGMENT_REV) {
         vis_ASurfNumPoints (asurf,&numpnt);
         vis_ASurfNumSegments (asurf,&numseg);
         printf("Segment Rev, id= %d, numpnts= %d, numseg= %d\n",
                              id,numpnt,numseg);
         vis_ASurfGetSegmentRevdv (asurf,a,b,c);
         printf("             a= %f %f %f\n",a[0],a[1],a[2]);
         printf("             b= %f %f %f\n",b[0],b[1],b[2]);
         printf("             c= %f %f %f\n",c[0],c[1],c[2]);
      } else if(type == ASURF_SEGMENT_RULE) {
         vis_ASurfNumPoints (asurf,&numpnt);
         vis_ASurfNumSegments (asurf,&numseg);
         printf("Segment Rule, id= %d, numpnts= %d, numseg= %d\n",
                              id,numpnt,numseg);
         vis_ASurfGetSegmentRuledv (asurf,a,b,c);
         printf("             a= %f %f %f\n",a[0],a[1],a[2]);
         printf("             b= %f %f %f\n",b[0],b[1],b[2]);
         printf("             c= %f %f %f\n",c[0],c[1],c[2]);
      }
   }
}

/*----------------------------------------------------------------------
                      print solution properties
----------------------------------------------------------------------*/
static void
printSProp(vsy_List *splist)
{
   Vint i, j;
   vis_SProp *sprop;
   Vint id;
   Vint sptype;
   Vint ntypes, *type;
   Vint flag, nval, dtyp;
   Vchar name[64];
   Vint iparams[100];
   Vdouble dparams[100];
   Vchar cparams[81];

   printf("\nSolution Properties\n");
   vsy_ListInitIter (splist);
   while(vsy_ListNextIter(splist,&id,(Vobject**)&sprop),sprop) {
      printf("id= %d, type= ",id);
      vis_SPropInq (sprop,&sptype);
      if(sptype == SYS_SOL_STATIC) {
         printf(" Static Analysis Property\n");
      } else if(sptype == SYS_SOL_VIBRATION) {
         printf(" Vibration Analysis Property\n");
      } else if(sptype == SYS_SOL_BUCKLING) {
         printf(" Buckling Analysis Property\n");
      } else if(sptype == SYS_SOL_TRANSIENT) {
         printf(" Transient Analysis Property\n");
      }
      vis_SPropValueTypeNum (sprop,&ntypes);
      type = (Vint*)malloc(ntypes*sizeof(Vint));
      vis_SPropValueType (sprop,&ntypes,type);

                   /* loop through types generically */
      for(i = 0; i < ntypes; i++) {
         vis_SPropValueName (sprop,type[i],name);
         printf("\n name = %s\n",name);
         vis_SPropValueFlag (sprop,type[i],&flag);
         if(flag == SPROP_UNDEFINED) {
            printf("Undefined\n");
         } else {
            vis_SPropValueParams (sprop,type[i],&nval,&dtyp);
            printf(" nval= %d\n",nval);
                   /* check for too many values for array size */ 
            if(nval > 100)  continue;
                   /* integer valued */
            if(dtyp == SYS_INTEGER) {
               printf(" Integer\n");
               vis_SPropValueInteger (sprop,type[i],iparams);
               for(j = 0; j < nval; j++) {
                  printf("  value= %d\n",iparams[j]);
               }
                   /* real valued */
            } else if(dtyp == SYS_REAL) {
               vis_SPropValueDouble (sprop,type[i],dparams);
               printf(" Real\n");
               for(j = 0; j < nval; j++) {
                  printf("  value= %e\n",dparams[j]);
               }
                   /* character valued */
            } else if(dtyp == SYS_CHAR) {
               vis_SPropValueString (sprop,type[i],cparams);
               printf("  value= %s\n",cparams);
            }
         }
      }
      free(type);
   }
}

Table of Contents

25.41 Example 39c, Heat Transfer Finite Element Model Using Model

This example illustrates the use of a Model object hierarchy to manage a heat transfer finite element model. This example is similar to the structural model illustrated in Example 39a. In this case material properties, restraints and loads are changed to reflect heat transfer analysis. Also the analysis type in the SProp object is changed to SYS_ANALYSIS_THERMAL.

#include "base/base.h"
#include "vis/vis.h"
/*
                 5------6
                /.     /.\
               / .    / . \
              /  .   /  .  \70------80
             /   1../...2../|       |  \
           12-----13-----14 |       |    \
            |  .   |  .   |.|       |      \
            | .    | .    | 30------40------15-----18
            |.     |.     |/
            9-----10-----11
            \      /    /
             \tet /wed /
              \  /    /
               16----17
*/
#define MAX_ELEM  7
#define MAX_NODE 18

                   /* element connectivity */ 
static Vint conn[MAX_ELEM][8] = {
   {1, 2, 6, 5, 9,10,13,12},
   {2,30,70, 6,10,11,14,13},
  {30,40,80,70, 0, 0, 0, 0},
  {40,15,80, 0, 0, 0, 0, 0},
   {9,10,13,16, 0, 0, 0, 0},
  {10,13,16,11,14,17, 0, 0},
  {15,18, 0, 0, 0, 0, 0, 0} };

                   /* user element ids */ 
static Vint eid[MAX_ELEM] = {
   10,11,20,21,30,31,100 };

                   /* element topologies */ 
static Vint shap[MAX_ELEM] = {
   VIS_SHAPEHEX, VIS_SHAPEHEX, VIS_SHAPEQUAD, VIS_SHAPETRI,
   VIS_SHAPETET, VIS_SHAPEWED, VIS_SHAPELINE };
static Vint maxi[MAX_ELEM] = {
   0, 0, 0, 0, 0, 0, 0 };

                   /* element types */ 
static Vint featype[MAX_ELEM] = {
   VIS_ELEM_SOLID, VIS_ELEM_SOLID, VIS_ELEM_SHELL, VIS_ELEM_SHELL,
   VIS_ELEM_SOLID, VIS_ELEM_SOLID, VIS_ELEM_BEAM };

                   /* element specs */ 
static Vint feaspec[MAX_ELEM] = {
   0, 0, 0, 0,
   0, 0, 0 };

                   /* element property ids */ 
static Vint pid[MAX_ELEM] = {
   1, 1, 2, 2, 1, 1, 3 };

                   /* element coordinate system indicators and ids */ 
static Vint ecid[MAX_ELEM] = {
   0, 0, 0, 0, 0, 0, SYS_ELEMSYS_VECTOR };

                   /* node coordinates */ 
static Vdouble coords[MAX_NODE][3] = {
   {0.,0.,0.},  {1.,0.,0.},  {2.,0.,1.}, {3.,0.,1.}, 
   {0.,1.,0.},  {1.,1.,0.},  {2.,1.,1.}, {3.,1.,1.}, 
   {0.,0.,2.},  {1.,0.,2.},  {2.,0.,2.},
   {0.,1.,2.},  {1.,1.,2.},  {2.,1.,2.},
   {4.,0.,1.},  {1.,0.,3.},  {2.,0.,3.}, {5.,0.,1.} };

                   /* user node ids */ 
static Vint nid[MAX_NODE] = {
   1, 2,30,40, 5, 6,70,80, 9,10,11,12,13,14,15,16,17,18 };

/*----------------------------------------------------------------------
                      Manage a Heat Transfer Finite Element Model Using Model
----------------------------------------------------------------------*/
int
main()
{
   Vint i;
   vis_Model *model;
   vis_Connect *connect;
   vis_ElemDat *elemdatthk, *elemdatvec;
   vis_GridFun *gf;
   vis_MProp *mprop;
   vis_EProp *eprop;
   vis_SProp *sprop;
   vis_ICase *icase;
   vis_RCase *rcase;
   vis_LCase *lcase;
   vsy_HashTable *ephash, *mphash, *edhash, *ichash, *rchash, *lchash;
   vsy_List *splist;
   Vdouble cflux;
   Vdouble thk[4];
   Vdouble vec[3], flux[4], conv[8];
   Vdouble val;
   Vint tag;
   vis_IdTran *idtrannode, *idtranelem;
   Vint nix, conntran[8];
   Vint id;

                   /* create connect object */
   connect = vis_ConnectBegin ();
   vis_ConnectPre (connect,SYS_DOUBLE);
   vis_ConnectDef (connect,MAX_NODE,MAX_ELEM);

                   /* set up user node and element id translation */ 
   idtrannode = vis_IdTranBegin();
   for(i = 0; i < MAX_NODE; i++) {
      vis_IdTranSetId (idtrannode,i+1,nid[i]);
   }
   idtranelem = vis_IdTranBegin();
   for(i = 0; i < MAX_ELEM; i++) {
      vis_IdTranSetId (idtranelem,i+1,eid[i]);
   }
                   /* set node coordinates */ 
   for(i = 0; i < MAX_NODE; i++) {
      vis_ConnectSetCoordsdv (connect,i+1,coords[i]);
      vis_ConnectSetNodeAssoc (connect,VIS_USERID,i+1,nid[i]);
   }

                   /* set element topologies */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetTopology (connect,i+1,shap[i],maxi[i],0,0);
   }

                   /* set element node connectivity and associations */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectElemNum (connect,SYS_NODE,i+1,&nix);
      vis_IdTranIndices (idtrannode,nix,conn[i],conntran);
      vis_ConnectSetElemNode (connect,i+1,conntran);
      vis_ConnectSetElemAssoc (connect,VIS_USERID,i+1,eid[i]);
      vis_ConnectSetElemAssoc (connect,VIS_FEATYPE,i+1,featype[i]);
      vis_ConnectSetElemAssoc (connect,VIS_FEASPEC,i+1,feaspec[i]);
      vis_ConnectSetElemAssoc (connect,VIS_PROPID,i+1,pid[i]);
      vis_ConnectSetElemAssoc (connect,VIS_CSYSID,i+1,ecid[i]);
   }

                   /* create model object hierarchy */ 
   model = vis_ModelBegin ();

                   /* hashtables of element and material properties */
   ephash = vsy_HashTableBegin ();
   mphash = vsy_HashTableBegin ();

                   /* hashtables of element data */
   edhash = vsy_HashTableBegin ();

                   /* hashtables of initial condition, restraint, load cases */
   ichash = vsy_HashTableBegin ();
   rchash = vsy_HashTableBegin ();
   lchash = vsy_HashTableBegin ();

                   /* list of solution procedures */ 
   splist = vsy_ListBegin ();

                   /* material 1 */ 
   mprop = vis_MPropBegin ();
   vis_MPropDef (mprop,SYS_MAT_ISOTROPIC);
   vis_MPropSetValued (mprop,MPROP_K,1.e+3);
   vsy_HashTableInsert (mphash,1,mprop);

                   /* solid property 1 */ 
   eprop = vis_EPropBegin ();
   vis_EPropDef (eprop,VIS_ELEM_SOLID);
   vis_EPropSetValuei (eprop,EPROP_MID,1);
   vsy_HashTableInsert (ephash,1,eprop);

                   /* shell property 2 */ 
   eprop = vis_EPropBegin ();
   vis_EPropDef (eprop,VIS_ELEM_SHELL);
   vis_EPropSetValuei (eprop,EPROP_MID,1);
   vis_EPropSetValued (eprop,EPROP_THICKNESS,.5);
   vsy_HashTableInsert (ephash,2,eprop);

                   /* beam property 3 */
   eprop = vis_EPropBegin ();
   vis_EPropDef (eprop,VIS_ELEM_BEAM);
   vis_EPropSetValuei (eprop,EPROP_MID,1);
   vis_EPropSetValued (eprop,EPROP_AREA,2.0);
   vsy_HashTableInsert (ephash,3,eprop);

                   /* GridFun for element data objects */ 
   gf = vis_GridFunBegin ();
   vis_ConnectGridFun (connect,gf);

                   /* ElemDat of shell element node thickness */ 
   elemdatthk = vis_ElemDatBegin ();
   vis_ElemDatDef (elemdatthk,MAX_ELEM,SYS_ELEM,SYS_NODE,SYS_SCALAR);
   vis_ElemDatSetObject (elemdatthk,VIS_GRIDFUN,gf);

                   /* ElemDat of beam element orientation vectors */ 
   elemdatvec = vis_ElemDatBegin ();
   vis_ElemDatDef (elemdatvec,MAX_ELEM,SYS_ELEM,SYS_NONE,SYS_VECTOR);
   vis_ElemDatSetObject (elemdatvec,VIS_GRIDFUN,gf);

                   /* shell element 21 is tapered */ 
   thk[0] = .5;
   thk[1] = .3;
   thk[2] = .5;
   vis_IdTranIndex (idtranelem,21,&id);
   vis_ElemDatSetDatadv (elemdatthk,id,0,thk);
   vsy_HashTableInsert (edhash,SYS_PROP_THICKNESS,elemdatthk);

                   /* beam element 100 orientation vector */ 
   vec[0] = 0.;
   vec[1] = 1.;
   vec[2] = 0.;
   vis_IdTranIndex (idtranelem,100,&id);
   vis_ElemDatSetDatadv (elemdatvec,id,0,vec);
   vsy_HashTableInsert (edhash,SYS_PROP_ELEMVEC,elemdatvec);

                   /* restraint case 1 */ 
   rcase = vis_RCaseBegin ();
   val = 120.;
   for(i = 1; i <= 3; i++) {
      vis_RCaseSetSPCdv (rcase,i,SYS_DOF_TEMP,RCASE_APPLIED,&val,0);
   }
   vsy_HashTableInsert (rchash,1,rcase);

                   /* load case 1 */ 
   lcase = vis_LCaseBegin ();

                   /* concentrated flux on node 12 */ 
   cflux = 2.;
   vis_IdTranIndex (idtrannode,12,&id);
   vis_LCaseSetConcdv (lcase,id,LCASE_HEAT,&cflux);

                   /* initial condition case number 2,
                      try to avoid using load or restraint case number */ 
   icase = vis_ICaseBegin ();
   tag = SYS_DOF_TEMP;
   val = 120.;
   for(i = 1; i <= MAX_NODE; i++) {
      vis_ICaseSetSPVdv (icase,i,ICASE_DOF,1,&tag,&val);
   }
   vsy_HashTableInsert (ichash,2,icase);

                   /* register GridFun object with LCase */
   vis_LCaseSetObject (lcase,VIS_GRIDFUN,gf);
                   /* uniform edge flux on edge 1 element 20 */ 
   flux[0] = 50.;
   flux[1] = 50.;
   vis_IdTranIndex (idtranelem,20,&id);
   vis_LCaseSetDistdv (lcase,SYS_EDGE,id,1,LCASE_HEATFLUX,flux);
                   /* uniform edge flux on edge 1 element 21 */ 
   vis_IdTranIndex (idtranelem,21,&id);
   vis_LCaseSetDistdv (lcase,SYS_EDGE,id,1,LCASE_HEATFLUX,flux);
                   /* uniform face convection on face 2 element 10 */ 
   conv[0] = 100.;
   conv[1] = 4.;
   conv[2] = 100.;
   conv[3] = 4.;
   conv[4] = 100.;
   conv[5] = 4.;
   conv[6] = 100.;
   conv[7] = 4.;
   vis_IdTranIndex (idtranelem,10,&id);
   vis_LCaseSetDistdv (lcase,SYS_FACE,id,2,LCASE_HEATCONV,conv);
   vsy_HashTableInsert (lchash,1,lcase);

                   /* solution step 1 */
   sprop = vis_SPropBegin ();
   vis_SPropDef (sprop,SYS_SOL_TRANSIENT);
   vis_SPropSetValuei (sprop,SPROP_ANALYSIS,SYS_ANALYSIS_THERMAL);
   vis_SPropSetValuei (sprop,SPROP_CASEID,1);
   vis_SPropSetValuei (sprop,SPROP_ICASE,2);
   vis_SPropSetValuei (sprop,SPROP_RCASE,1);
   vis_SPropSetValued (sprop,SPROP_RCASE_FACTOR,1.);
   vis_SPropSetValuei (sprop,SPROP_LCASE_NUM,1);
   vis_SPropSetValuei (sprop,SPROP_LCASE,1);
   vis_SPropSetValued (sprop,SPROP_LCASE_FACTOR,1.);
   vis_SPropSetValued (sprop,SPROP_TIME_INIT,0.);
   vis_SPropSetValued (sprop,SPROP_TIME_STEP,.1);
   vis_SPropSetValued (sprop,SPROP_TIME_TERM,2.);
   vsy_ListInsert (splist,1,sprop);

                   /* register Connect in Model */ 
   vis_ModelSetObject (model,VIS_CONNECT,connect);

                   /* register property hashtables in Model */ 
   vis_ModelSetHashTable (model,VIS_MPROP,mphash);
   vis_ModelSetHashTable (model,VIS_EPROP,ephash);

                   /* register element data hashtables in Model */ 
   vis_ModelSetHashTable (model,VIS_ELEMDAT,edhash);

                   /* register case hashtables in Model */ 
   vis_ModelSetHashTable (model,VIS_ICASE,ichash);
   vis_ModelSetHashTable (model,VIS_RCASE,rchash);
   vis_ModelSetHashTable (model,VIS_LCASE,lchash);

                   /* register solution property list in Model */ 
   vis_ModelSetList (model,VIS_SPROP,splist);
  
                   /* print to standard output */ 
   vis_ModelPrint (model);
                   /* write NASTRAN Bulk Data File */ 
   vis_ModelWrite (model,SYS_NASTRAN_BULKDATA,"exam39c.bdf");
                   /* write ABAQUS Input Data File */ 
   vis_ModelWrite (model,SYS_ABAQUS_INPUT,"exam39c.inp");
                   /* write ANSYS Input Data File */ 
   vis_ModelWrite (model,SYS_ANSYS_INPUT,"exam39c.cdb");
                   /* write Ideas Universal File */ 
   vis_ModelWrite (model,SYS_SDRC_UNIVERSAL,"exam39c.unv");
                   /* write PATRAN Neutral File */ 
   vis_ModelWrite (model,SYS_PATRAN_NEUTRAL,"exam39c.out");
   
                   /* end objects */ 
   vis_IdTranEnd (idtrannode);
   vis_IdTranEnd (idtranelem);
   vis_GridFunEnd (gf);
   vis_ConnectEnd (connect);
   vsy_HashTableForEach (ephash,(void(*)(Vobject*))vis_EPropEnd);
   vsy_HashTableEnd (ephash);
   vsy_HashTableForEach (mphash,(void(*)(Vobject*))vis_MPropEnd);
   vsy_HashTableEnd (mphash);
   vsy_HashTableForEach (edhash,(void(*)(Vobject*))vis_ElemDatEnd);
   vsy_HashTableEnd (edhash);
   vsy_ListForEach (splist,(void(*)(Vobject*))vis_SPropEnd);
   vsy_ListEnd (splist);
   vsy_HashTableForEach (ichash,(void(*)(Vobject*))vis_ICaseEnd);
   vsy_HashTableEnd (ichash);
   vsy_HashTableForEach (rchash,(void(*)(Vobject*))vis_RCaseEnd);
   vsy_HashTableEnd (rchash);
   vsy_HashTableForEach (lchash,(void(*)(Vobject*))vis_LCaseEnd);
   vsy_HashTableEnd (lchash);
   vis_ModelEnd (model);
   return 0;
}
BP Table of Contents

25.42 Example 40vdm, Compute Shell and Beam Local Coordinate Systems

This example illustrates loading a Model object with a finite element model residing on an external file and then computing and printing the local coordinate system direction cosine matrices associated with shell and beam elements in the model. The external file name is entered as the first argument to the example executable. The model object is created and then loaded using the function vdm_LManLoadModel. All elements in the model are traversed and all shell and beam elements are processed. In general, computing local coordinate systems requires accessing the user defined coordinate systems, element geometry and auxiliary vectors used to define the element local and material local coordinate systems.

The VIS_CSYSID element association specifies the element local system in which element results are expressed by default. The VIS_CMATID element association specifies the material local system in which element material properties are aligned. The VIS_CMATID is only applicable if the VIS_CMATFLAG element association is non zero. Any positive integer points to a user defined CoordSys object which resides in the HashTable of coordinate systems. Any negative integer represents an algorithm dependent on element geometry and possibly an auxiliary vector. The auxiliary vectors are contained in ElemDat objects which reside in a HashTable. Use vis_ModelGetHashTable to get the HashTable objects associated with CoordSys and ElemDat objects.

The ShellElem and BeamElem objects are used to compute the direction cosine matrices of the element local systems. They require the element geometry and auxiliary local system information. Use vis_ShellElemDirCos and vis_BeamElemDirCos to compute the element local systems.

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

static void
printShellBeam(vis_Model *model);

/*----------------------------------------------------------------------
                      Compute Shell and Beam Local Coordinate Systems
----------------------------------------------------------------------*/
int
main(int argc, char **argv)
{
   char inputfile[256];
   vdm_ABAFil  *abafil;
   vdm_ABALib  *abalib;
   vdm_ANSFil  *ansfil;
   vdm_ANSLib  *anslib;
   vdm_NASFil  *nasfil;
   vdm_NASLib  *naslib;
   vdm_NatLib  *natlib;
   vdm_SDRCLib *sdrclib;
   vdm_DataFun *datafun;
   vdm_LMan    *lman;
   Vint filetype;
   vis_Model *model;

   if(argc < 2) {
      fprintf(stderr,"Usage: %s inputfile\n",argv[0]);
      fprintf(stderr," inputfile is blank, 'shell.bdf' is assumed\n");
      strcpy(inputfile,"shell.bdf");
   } else {
      strcpy(inputfile,argv[1]);
   }

                   /* create data function object */
   datafun = vdm_DataFunBegin ();

                   /* determine file type from file extension */
   if(strstr(inputfile,".bdf") != NULL  ||
      strstr(inputfile,".dat") != NULL) {
      filetype = VDM_NASTRAN_BULKDATA;
      nasfil = vdm_NASFilBegin ();
      vdm_NASFilDataFun (nasfil,datafun);
      printf("Nastran Bulk Data File: %s\n",inputfile);
   } else if(strstr(inputfile,".op2") != NULL) {
      filetype = VDM_NASTRAN_OUTPUT2;
      naslib = vdm_NASLibBegin ();
      vdm_NASLibDataFun (naslib,datafun);
      printf("Nastran Output2 File: %s\n",inputfile);
   } else if(strstr(inputfile,".vdm") != NULL) {
      filetype = VDM_NATIVE;
      natlib = vdm_NatLibBegin ();
      vdm_NatLibDataFun (natlib,datafun);
      printf("Native File: %s\n",inputfile);
   } else if(strstr(inputfile,".inp") != NULL) {
      filetype = VDM_ABAQUS_INPUT;
      abafil = vdm_ABAFilBegin ();
      vdm_ABAFilDataFun (abafil,datafun);
      printf("Abaqus Input File: %s\n",inputfile);
   } else if(strstr(inputfile,".fil") != NULL) {
      filetype = VDM_ABAQUS_FIL;
      abalib = vdm_ABALibBegin ();
      vdm_ABALibDataFun (abalib,datafun);
      printf("Abaqus Binary (.fil) File: %s\n",inputfile);
   } else if(strstr(inputfile,".cdb") != NULL) {
      filetype = VDM_ANSYS_INPUT;
      ansfil = vdm_ANSFilBegin ();
      vdm_ANSFilDataFun (ansfil,datafun);
      printf("Ansys Input File: %s\n",inputfile);
   } else if(strstr(inputfile,".rst") != NULL) {
      filetype = VDM_ANSYS_RESULT;
      anslib = vdm_ANSLibBegin ();
      vdm_ANSLibDataFun (anslib,datafun);
      printf("Ansys Result (.rst) File: %s\n",inputfile);
   } else if(strstr(inputfile,".unv") != NULL) {
      filetype = VDM_SDRC_UNIVERSAL;
      sdrclib = vdm_SDRCLibBegin ();
      vdm_SDRCLibDataFun (sdrclib,datafun);
      printf("SDRC Universal File: %s\n",inputfile);
   } else {
      fprintf(stderr,"Error: Bad input file %s\n",inputfile);
      exit(1);
   }
                   /* open library device */
   vdm_DataFunOpen (datafun,0,inputfile,filetype);

                   /* instance model object for finite element model */
   model = vis_ModelBegin();

                   /* use Library Manager object to load model */
   lman = vdm_LManBegin ();
   vdm_LManSetObject (lman,VDM_DATAFUN,datafun);
   vdm_LManLoadModel (lman,model);
   if(vdm_LManError(lman)) {
      fprintf(stderr,"Error: Unable to load model information\n");
      exit(1);
   }
                   /* close library device and delete interface */
   vdm_DataFunClose (datafun);
   vdm_DataFunEnd (datafun);
   if(filetype == VDM_NASTRAN_BULKDATA) {
      vdm_NASFilEnd (nasfil);
   } else if(filetype == VDM_NASTRAN_OUTPUT2) {
      vdm_NASLibEnd (naslib);
   } else if(filetype == VDM_NATIVE) {
      vdm_NatLibEnd (natlib);
   } else if(filetype == VDM_ABAQUS_INPUT) {
      vdm_ABAFilEnd (abafil);
   } else if(filetype == VDM_ABAQUS_FIL) {
      vdm_ABALibEnd (abalib);
   } else if(filetype == VDM_ANSYS_INPUT) {
      vdm_ANSFilEnd (ansfil);
   } else if(filetype == VDM_ANSYS_RESULT) {
      vdm_ANSLibEnd (anslib);
   } else if(filetype == VDM_SDRC_UNIVERSAL) {
      vdm_SDRCLibEnd (sdrclib);
   }
   vdm_LManEnd (lman);

                   /* print shell and beam systems */ 
   printShellBeam (model);
                   /* delete objects registered in Model */
   vis_ModelDelete (model);
                   /* destroy Model object itself */
   vis_ModelEnd (model);
   return 0;
}

/*----------------------------------------------------------------------
                      print shell and beam coordinate systems
----------------------------------------------------------------------*/
static void
computeShellBeam(Vint index, Vint featype, Vint cid,
                 Vint shape, Vint maxi, Vint maxj,
                 vis_ShellElem *shellelem, vis_BeamElem *beamelem,
                 vsy_HashTable *coordsyshash, vis_ElemDat *elemdat,
                 Vfloat xe[][3], Vfloat tme[3][3])
{
   Vfloat xo[3], tm[3][3];
   vis_CoordSys *coordsys;
   Vint type;
   Vfloat vec[3];
                   /* user defined coordinate system */
   if(cid > 0) {
      if(coordsyshash == NULL) {
         printf("Error: no HashTable of CoordSys objects\n");
         exit(0);
      }
      vsy_HashTableLookup (coordsyshash,cid,(Vobject**)&coordsys);
      if(coordsys == NULL) {
         printf("Error: no CoordSys object\n");
         exit(0);
      }
      vis_CoordSysOriginTriad (coordsys,xo,tm);
      type = SYS_ELEMSYS_VECTOR;
      vec[0] = tm[0][0];
      vec[1] = tm[0][1];
      vec[2] = tm[0][2];
                   /* algorithmic */
   } else if (cid < 0) {
      type = cid;
      if(elemdat) {
         vis_ElemDatData (elemdat,index,0,vec);
      }
                   /* global, cid = 0 */
   } else {
      type = cid;
   }
                   /* shell or beam */ 
   if(featype == SYS_ELEM_SHELL) {
      vis_ShellElemSetTopology (shellelem,shape,maxi,maxj);
      vis_ShellElemSetLocalSystem (shellelem,type,vec,0.);
      vis_ShellElemDirCos (shellelem,SYS_ON,xe,(Vfloat(*)[3][3])tme);
   } else if(featype == SYS_ELEM_BEAM) {
      vis_BeamElemSetTopology (beamelem,shape,maxi);
      vis_BeamElemSetLocalSystem (beamelem,type,vec,0.);
      vis_BeamElemDirCos (beamelem,SYS_ON,xe,VIS_NODATA,NULL,VIS_NODATA,NULL,
                          (Vfloat(*)[3][3])tme);
   }
}

static void
printShellBeam(vis_Model *model)
{
   Vint i;
   Vint numnp, numel;
   Vint eid, csysid, cmatid, cmatflag;
   Vint featype;
   Vfloat xe[16][3], tme[3][3];
   Vint nix, ix[16];
   Vint shape, maxi, maxj, maxk;
   vis_Connect *connect;
   vis_ShellElem *shellelem;
   vis_BeamElem *beamelem;
   vsy_HashTable *elemdathash, *coordsyshash;
   vis_ElemDat *edcsysid, *edcmatid;

   vis_ModelGetObject (model,VIS_CONNECT,(Vobject**)&connect);
   if(connect == NULL) {
      printf("Error: no Connect object\n");
      exit(0);
   }
   vis_ModelGetHashTable (model,VIS_ELEMDAT,&elemdathash);
   if(elemdathash) {
      vsy_HashTableLookup (elemdathash,SYS_PROP_ELEMVEC,(Vobject**)&edcsysid);
      vsy_HashTableLookup (elemdathash,SYS_PROP_MATLVEC,(Vobject**)&edcmatid);
   }
   vis_ModelGetHashTable (model,VIS_COORDSYS,&coordsyshash);

   vis_ConnectNumber (connect,SYS_NODE,&numnp);
   vis_ConnectNumber (connect,SYS_ELEM,&numel);
   printf("Number of nodes=    %d\n",numnp);
   printf("Number of elements= %d\n",numel);
   shellelem = vis_ShellElemBegin ();
   beamelem = vis_BeamElemBegin ();

                   /* process shell and beam elements */ 
   for(i = 1; i <= numel; i++) {
      vis_ConnectElemAssoc (connect,VIS_FEATYPE,1,&i,&featype);
      if(featype != SYS_ELEM_SHELL &&
         featype != SYS_ELEM_BEAM)  continue;
      vis_ConnectTopology (connect,i,&shape,&maxi,&maxj,&maxk);
      vis_ConnectElemNode (connect,i,&nix,ix);
      vis_ConnectCoords (connect,nix,ix,xe);
      vis_ConnectElemAssoc (connect,VIS_USERID,1,&i,&eid);
      vis_ConnectElemAssoc (connect,VIS_CSYSID,1,&i,&csysid);
      vis_ConnectElemAssoc (connect,VIS_CMATFLAG,1,&i,&cmatflag);
      vis_ConnectElemAssoc (connect,VIS_CMATID,1,&i,&cmatid);
                   /* element results in CSYSID system */
      computeShellBeam (i,featype,csysid,shape,maxi,maxj,
                        shellelem,beamelem,coordsyshash,edcsysid,xe,tme);
      printf("element= %d, element result system= %d\n",eid,csysid);
      printf("x'= %10f %10f %10f\n",tme[0][0],tme[0][1],tme[0][2]);
      printf("y'= %10f %10f %10f\n",tme[1][0],tme[1][1],tme[1][2]);
      printf("z'= %10f %10f %10f\n",tme[2][0],tme[2][1],tme[2][2]);
                   /* element CMATID system */
      if(cmatflag) {
         computeShellBeam (i,featype,cmatid,shape,maxi,maxj,
                           shellelem,beamelem,coordsyshash,edcmatid,xe,tme);
         printf("element= %d, element material system= %d\n",eid,cmatid);
         printf("x'= %10f %10f %10f\n",tme[0][0],tme[0][1],tme[0][2]);
         printf("y'= %10f %10f %10f\n",tme[1][0],tme[1][1],tme[1][2]);
         printf("z'= %10f %10f %10f\n",tme[2][0],tme[2][1],tme[2][2]);
      }
   }
   vis_ShellElemEnd (shellelem);
   vis_BeamElemEnd (beamelem);
}

Table of Contents

25.43 Example 53, Manage System Degree of Freedom Data Using RedMat

This example illustrates the use of a RedMat object to manage degree of freedom data. The normal use of this object is to store superelement mass and/or stiffness matrices and superelement loads. The RedMat object can be configured to hold vectors as well as diagonal, symmetric and unsymmetric matrices. The data may be real or complex. By default the data is help internally in double precision. The vis_RedMatDef function is used to specify the number of columns of the vector or matrix and the vector or matrix structure. The function vis_RedMatSetDatadv is used to set the double precision values of the vector or matrix. The function vis_RedMatSetDof may be optionally used to associate a entity index and degree of freedom tag with each row of the vector or matrix. Use vis_RedMatDatadv to query the double precision values of the vector or matrix and vis_RedMatGetDof to get the associated entity index and degree of freedom tags. Note that the function vis_RedMatSetComplexMode must be called with SYS_COMPLEX_REALIMAGINARY to enter real and imaginary parts of complex valued data. By default the complex mode is SYS_COMPLEX_REAL.

#include "base/base.h"
#include "vgl/vgl.h"
#include "vis/vis.h"

/*----------------------------------------------------------------------
                      Manage System Degree of Freedom Data Using RedMat
----------------------------------------------------------------------*/
int
main()
{
   vis_RedMat *redmat;
   Vint i, j, n, doftag;
   Vfloat fv[2];
   Vdouble dv[2];

   redmat = vis_RedMatBegin ();
                   /* define a diagonal matrix */ 
   vis_RedMatDef (redmat,10,SYS_MATRIX_DIAG);
   for(i = 1; i <= 10; ++i) {
      dv[0] = i;
      vis_RedMatSetDatadv (redmat,i,i,dv);
   }
   printf("SYS_MATRIX_DIAG:\n");
   for(i = 1; i <= 10; ++i) {
      vis_RedMatData (redmat,i,i,fv);
      printf("   i= %2d, j= %2d, fv= %11.4e\n",i,i,fv[0]);
   }
   for(i = 1; i <= 10; ++i) {
      vis_RedMatDatadv (redmat,i,i,dv);
      printf("   i= %2d, j= %2d, dv= %11.4e\n",i,i,dv[0]);
   }
                   /* define a complex symmetric matrix, lower triangle */ 
   vis_RedMatDef (redmat,10,SYS_MATRIX_SYMM);
   vis_RedMatSetComplexMode (redmat,SYS_COMPLEX_REALIMAGINARY);
   for(n = 1, j = 1; j <= 10; ++j) {
      for(i = 1; i <= j; ++i, ++n) {
         dv[0] = 2*n;
         dv[1] = 2*n+1;
         vis_RedMatSetDatadv (redmat,i,j,dv);
      }
   }
                   /* add associated entity index and dof tag */
                   /* nodes 1 throught 5, doftags translation x and y */
   for(i = 1; i <= 10; ++i) {
      n = (i-1)/2 + 1;
      if((i-1)%2 == 0) {
         doftag = SYS_DOF_TX;
      } else {
         doftag = SYS_DOF_TY;
      }
      vis_RedMatSetDof (redmat,i,n,doftag);
   }

   printf("SYS_MATRIX_SYMM:\n");
   for(j = 1; j <= 10; ++j) {
      vis_RedMatGetDof (redmat,j,&n,&doftag);
      printf("   j= %2d, n= %d, doftag= %d\n",j,n,doftag);
      for(i = 1; i <= j; ++i) {
         vis_RedMatData (redmat,i,j,fv);
         printf("   i= %2d, j= %2d, fv= %11.4e %11.4e\n",i,j,fv[0],fv[1]);
      }
   }
   for(j = 1; j <= 10; ++j) {
      for(i = 1; i <= j; ++i) {
         vis_RedMatDatadv (redmat,i,j,dv);
         printf("   i= %2d, j= %2d, dv= %11.4e\n",i,j,dv[0]);
      }
   }
                   /* define an unsymmetric matrix */ 
   vis_RedMatDef (redmat,10,SYS_MATRIX_USYMM);
   vis_RedMatSetComplexMode (redmat,SYS_COMPLEX_REAL);
   for(n = 1, j = 1; j <= 10; ++j) {
      for(i = 1; i <= 10; ++i, ++n) {
         dv[0] = n;
         vis_RedMatSetDatadv (redmat,i,j,dv);
      }
   }
   printf("SYS_MATRIX_USYMM:\n");
   for(j = 1; j <= 10; ++j) {
      for(i = 1; i <= 10; ++i) {
         vis_RedMatData (redmat,i,j,fv);
         printf("   i= %2d, j= %2d, fv= %11.4e\n",i,j,fv[0]);
      }
   }
   for(j = 1; j <= 10; ++j) {
      for(i = 1; i <= 10; ++i) {
         vis_RedMatDatadv (redmat,i,j,dv);
         printf("   i= %2d, j= %2d, dv= %11.4e\n",i,j,dv[0]);
      }
   }
                   /* define a vector, single row */ 
   vis_RedMatDef (redmat,10,SYS_VECTOR);
   i = 1;
   for(j = 1; j <= 10; ++j) {
      dv[0] = j;
      vis_RedMatSetDatadv (redmat,i,j,dv);
   }
   printf("SYS_VECTOR:\n");
   for(j = 1; j <= 10; ++j) {
      vis_RedMatData (redmat,i,j,fv);
      printf("   i= %2d, j= %2d, fv= %11.4e\n",i,j,fv[0]);
   }
   for(j = 1; j <= 10; ++j) {
      vis_RedMatDatadv (redmat,i,j,dv);
      printf("   i= %2d, j= %2d, dv= %11.4e\n",i,j,dv[0]);
   }
                   /* destroy object */ 
   vis_RedMatEnd (redmat);
   return 0;
}

Table of Contents

25.44 Example 56, Computational Features of Edge, Face, Cell

This example illustrates using the computational features of the Edge, Face and Cell objects. In general each object will compute the natural coordinates of the center and nodes of edges, faces and cells respectively. They will also compute gradient vectors tangent to the natural coordinate directions at a given natural coordinate and perform interpolations of nodal variables to any natural coordinate location. In addition, the Face object will compute normal vectors to the face at each node. The Edge object will compute normalized tangent vectors to the edge at each node.

The geometries for the edge, face and cell are extracted from an array of coordinates generated cylindrically for a 10 node Lagrange tetrahedron.

#include <math.h>
#include "base/base.h"
#include "vis/vis.h"

/*----------------------------------------------------------------------
                      Computational Features of Edge, Face, Cell
----------------------------------------------------------------------*/
int
main()
{
   Vint i, j, k, n;
   vis_Edge *edge;
   vis_Face *face;
   vis_Cell *cell;
   Vint nix;
   Vfloat r[4], rs[16][2], rst[64][3];
   Vfloat radin, radout, dr, ang, da, z, dz, mag, rad;
   Vfloat x[64][3];
   Vfloat v[64][3], g[3][3];
   Vfloat rc[3], vc[3], xc[3];
                   /* generate cononical tet structure of nodes */
                   /* radin 10., radout = 20., height 2., ang= 45 degrees */ 
                   /* use for edge, face, cell geometry */
   n = 0;
   radin = 10.;
   radout = 20.;
   dr = (20.-10.)/2.;
   ang = 3.14149/4.;
   da = ang/2;
   z = 2.;
   dz = z/2;
   for(i = 0; i < 3; i++) {
      rad = radin + i*dr;
      for(j = 0; j < 3-i; j++) {
         for(k = 0; k < 3-j; k++) {
            x[n][0] = rad*cos(k*da);
            x[n][1] = rad*sin(k*da);
            x[n][2] = j*dz;
            n += 1;
         }
      }
   }
   printf("Tet coordinates at nodes\n");
   for(i = 0; i < n; i++) {
      printf("i= %d, x= %f %f %f\n",i,x[i][0],x[i][1],x[i][2]);
   }

                   /* create edge object */
                   /* reuse first 3 nodes of tet geometry */
   edge = vis_EdgeBegin ();
                   /* compute natural coordinates at nodes */
                   /* parabolic edge */
   vis_EdgeSetTopology (edge,VIS_SHAPELINE,3);
   vis_EdgeRST (edge,rc,&nix,r);
   printf("Natural coordinates at center\n");
   printf("center rc= %f\n",rc[0]);
   printf("Natural coordinates at nodes\n");
   for(i = 0; i < nix; i++) {
      printf("i= %d, r= %f\n",i,r[i]);
   }
                   /* edge tangents, normalized */
   vis_EdgeComputeTang (edge,x,v);
   printf("Edge normalized tangent vectors at nodes\n");
   for(i = 0; i < nix; i++) {
      printf("i= %d, v= %f %f %f\n",i,v[i][0],v[i][1],v[i][2]);
   }
                   /* edge gradient tangents */
   printf("Edge tangent vectors at nodes\n");
   for(i = 0; i < nix; i++) {
      vis_EdgeTangRST (edge,x,r[i],g[0]);
      printf("i= %d, g[0]= %f %f %f\n",
              i,g[0][0],g[0][1],g[0][2]);
   }
                   /* interpolate coordinates to center */
   vis_EdgeInterpolate (edge,rc[0],3,(Vfloat*)x,xc);
   printf("Edge center coordinate\n");
   printf("center xc= %f %f %f\n",xc[0],xc[1],xc[2]);

   vis_EdgeEnd (edge);

                   /* create face object */ 
                   /* reuse first 6 nodes of tet geometry */
   face = vis_FaceBegin ();
                   /* compute natural coordinates at nodes */
                   /* parabolic, Lagrange triangle */
   vis_FaceSetTopology (face,VIS_SHAPETRI,3,3);
   vis_FaceRST (face,rc,&nix,rs);
   printf("Natural coordinates at center\n");
   printf("center rc= %f %f\n",rc[0],rc[1]);
   printf("Natural coordinates at nodes\n");
   for(i = 0; i < nix; i++) {
      printf("i= %d, rs= %f %f\n",i,rs[i][0],rs[i][1]);
   }
                   /* face normals */ 
   vis_FaceComputeNorm (face,x,v);
   printf("Face normal vectors at nodes\n");
   for(i = 0; i < nix; i++) {
      printf("i= %d, v= %f %f %f\n",i,v[i][0],v[i][1],v[i][2]);
   }
                   /* face tangents */ 
   printf("Face gradient tangent vectors at nodes\n");
   for(i = 0; i < nix; i++) {
      vis_FaceTangRST (face,x,rs[i],g);
      printf("i= %d, g[0]= %f %f %f, g[1]= %f %f %f\n",
              i,g[0][0],g[0][1],g[0][2], g[1][0],g[1][1],g[1][2]);
   }
                   /* interpolate normal to center */
   vis_FaceInterpolate (face,rc,3,(Vfloat*)v,vc);
   printf("Face center normal vector\n");
                   /* normalize */ 
   mag = sqrt(vc[0]*vc[0] + vc[1]*vc[1] + vc[2]*vc[2]);
   vc[0] = vc[0]/mag;
   vc[1] = vc[1]/mag;
   vc[2] = vc[2]/mag;
   printf("center v= %f %f %f\n",vc[0],vc[1],vc[2]);

   vis_FaceEnd (face);

                   /* create cell object */ 
   cell = vis_CellBegin ();
                   /* compute natural coordinates at nodes */
                   /* parabolic, Lagrange tet */
   vis_CellSetTopology (cell,VIS_SHAPETET,3,3,3);
   vis_CellRST (cell,rc,&nix,rst);
   printf("Natural coordinates at center\n");
   printf("center rc= %f %f\n",rc[0],rc[1]);
   printf("Natural coordinates at nodes\n");
   for(i = 0; i < nix; i++) {
      printf("i= %d, rst= %f %f %f\n",i,rst[i][0],rst[i][1],rst[i][2]);
   }
                   /* cell tangents */
   printf("Cell gradient tangent vectors at nodes\n");
   for(i = 0; i < nix; i++) {
      vis_CellTangRST (cell,x,rst[i],g);
      printf("i= %d, g[0]= %f %f %f, g[1]= %f %f %f, g[2]= %f %f %f\n",
              i,g[0][0],g[0][1],g[0][2],
                g[1][0],g[1][1],g[1][2],
                g[2][0],g[2][1],g[2][2]);
   }
                   /* interpolate coordinates to center */
   vis_CellInterpolate (cell,rc,3,(Vfloat*)x,xc);
   printf("Cell center coordinate\n");
   printf("center xc= %f %f %f\n",xc[0],xc[1],xc[2]);

   vis_CellEnd (cell);

   return 0;
}

Table of Contents

25.45 Example 56, Using Units

This example illustrates using the Units module to store and retrieve a set of units termed base units. It also allows for the definition of a set of conversion units and associated conversion factors for transforming from base units to the conversion units. In this example the base units are set to SI. Note that setting the base unit also sets the conversion unit to the same value. The conversion units are set to typical British units. The call to vis_UnitsComputeFactors will automatically set the conversion factors between the defined base and conversion units. The user need only set factors manually using vis_UnitsSetFactor if either the base or conversion unit is user defined, for example if the conversion length unit is set to UNITS_LENGTH_USER. The computed conversion factors are queried using vis_UnitsGetFactor.

#include "base/base.h"
#include "vis/vis.h"
#include "glwin.h"

/*----------------------------------------------------------------------
                      Using Units
----------------------------------------------------------------------*/
int
main()
{
   vis_Units *units;
   Vdouble lfac, mfac, tfac, tempfac, tempoff;

                   /* create Units */
   units = vis_UnitsBegin ();

                   /* set base units to SI */ 
   vis_UnitsSetBase (units,UNITS_LENGTH,UNITS_LENGTH_METER);
   vis_UnitsSetBase (units,UNITS_MASS,UNITS_MASS_KILOGRAM);
   vis_UnitsSetBase (units,UNITS_TIME,UNITS_TIME_SECOND);
   vis_UnitsSetBase (units,UNITS_TEMP,UNITS_TEMP_KELVIN);

                   /* set conversion units to British */ 
   vis_UnitsSetConv (units,UNITS_LENGTH,UNITS_LENGTH_FOOT);
   vis_UnitsSetConv (units,UNITS_MASS,UNITS_MASS_POUND);
   vis_UnitsSetConv (units,UNITS_TIME,UNITS_TIME_SECOND);
   vis_UnitsSetConv (units,UNITS_TEMP,UNITS_TEMP_FAHRENHEIT);

                   /* compute conversion factors */
   vis_UnitsComputeFactors (units);

                   /* get and print factors */ 
   vis_UnitsGetFactor (units,UNITS_LENGTH,&lfac);
   vis_UnitsGetFactor (units,UNITS_MASS,&mfac);
   vis_UnitsGetFactor (units,UNITS_TIME,&tfac);
   vis_UnitsGetFactor (units,UNITS_TEMP,&tempfac);
   vis_UnitsGetFactor (units,UNITS_TEMP_OFFSET,&tempoff);
   printf("length, one meter is %e feet\n",lfac);
   printf("mass,   one kilogram is %e pounds\n",mfac);
   printf("time,   one second is %e seconds\n",tfac);
   printf("temp,   fahrenheit= %e * (kelvin + %e)\n",tempfac,tempoff);

                   /* free object */ 
   vis_UnitsEnd (units);
   return 0;
}

Table of Contents

25.46 Example 57, Compress and Uncompress Coordinate Field with ZState

This example illustrates using the ZState module to compress and uncompress a node coordinate field. In general ZState is most successful compressing fields with a high degree of spatial continuity. A ZState object is instanced and the function vis_ZStateDef is used to define a node based field for compression. A GridFun object is required to provide access to the model node locations and element connectivity, this object is set in ZState using vis_ZStateSetObject.

The ZState object first is used to generate the compression kernel. This is a model dependent data structure which is required for compressing field data and subsequently uncompressing any compressed field data. The compression kernel is computed using vis_ZStateKernel. Get a maximum length for the kernel using vis_ZStateLngKernel. Use this length to allocate memory for the kernel data structure. Use vis_ZStateSaveKernel to access the kernel, the actual length of the kernel is returned in newbytes and is, in general, less than the length returned by vis_ZStateLngKernel. Generally this data structure is written to a file by the user along with the compressed states for later access and decompression.

A State object is instanced and the node coordinate vector data is entered. The vis_ZStateState function is used to compress the state. In a manner similar to the kernel, the maximum length of the compressed state is returned using vis_ZStateLngState. Return the compressed state data and the actual length using vis_ZStateSaveState.

The uncompression process instances a new ZState and uses vis_ZStateLoadKernel to reestablish the compression kernel and vis_ZStateLoadState is uncompress the compressed state data into a new State object.

#include "base/system.h"
#include "base/base.h"
#include "vgl/vgl.h"
#include "vis/vis.h"
#include "vis/vismesh.h"


/*
                 5------6
                /.     /.\
  y            / .    / . \
  |           /  .   /  .  \7------8
  --x        /   1../...2../|      |
 /         12-----13-----14 |      |
z           |  .   |  .   |.|      |
            | .    | .    | 3------4
            |.     |.     |/
            9-----10-----11
*/

#define MAX_ELEM  3
#define MAX_NODE 14

static Vint conn[MAX_ELEM][8] = {
   { 1, 2, 6, 5, 9,10,13,12 },
   { 2, 3, 7, 6,10,11,14,13 },
   { 3, 4, 8, 7, 0, 0, 0, 0 } };

static Vint shap[MAX_ELEM] = {
   VIS_SHAPEHEX, VIS_SHAPEHEX, VIS_SHAPEQUAD };

static Vfloat coords[MAX_NODE][3] = {
   { 0.,0.,0.},  { 1.,0.,0.},  { 2.,0.,1.},  { 3.,0.,1.}, 
   { 0.,1.,0.},  { 1.,1.,0.},  { 2.,1.,1.},  { 3.,1.,1.}, 
   { 0.,0.,2.},  { 1.,0.,2.},  { 2.,0.,2.},
   { 0.,1.,2.},  { 1.,1.,2.},  { 2.,1.,2.} };

/*----------------------------------------------------------------------
          Compress and Uncompress Coordinate Field with ZState
----------------------------------------------------------------------*/
int
main(int argc, char **argv)
{
   vis_ZState  *zstate;
   vis_Connect *connect;
   vis_GridFun *gridfun;
   vis_State   *state;
   Vuchar *bkernel, *bstate;
   Vint i;
   Vulong nbytes, newbytes;
   Vfloat x[3];

                   /* create connect object */
   connect = vis_ConnectBegin ();
   vis_ConnectDef (connect,MAX_NODE,MAX_ELEM);

                   /* set topologies */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetTopology (connect,i+1,shap[i],2,0,0);
   }
                   /* set element node connectivity */ 
   for(i = 0; i < MAX_ELEM; i++) {
      vis_ConnectSetElemNode (connect,i+1,conn[i]);
   }
                   /* set node coordinates */ 
   for(i = 0; i < MAX_NODE; i++) {
      vis_ConnectSetCoords (connect,i+1,coords[i]);
   }
                   /* create GridFun */ 
   gridfun = vis_GridFunBegin ();
   vis_ConnectGridFun (connect,gridfun);

                   /* create ZState and Def it for nodal data */ 
   zstate = vis_ZStateBegin ();
   vis_ZStateDef (zstate,MAX_NODE,SYS_NODE,SYS_NONE);
   vis_ZStateSetObject (zstate,VIS_GRIDFUN,(Vobject*)gridfun);

                   /* create ZState kernel and save it */ 
   vis_ZStateKernel (zstate,NULL);
   vis_ZStateLngKernel (zstate,&nbytes);
   bkernel = (Vuchar*)malloc(nbytes*sizeof(Vuchar));
   vis_ZStateSaveKernel (zstate,bkernel,&newbytes);
   printf("Kernel size= %lld bytes, actual= %lld\n",nbytes,newbytes);
                   /* create coordinate state */ 
   state = vis_StateBegin ();
   vis_StateSetObject (state,VIS_GRIDFUN,(Vobject*)gridfun);
   vis_StateDef (state,MAX_NODE,SYS_NODE,SYS_NONE,SYS_VECTOR);
   for(i = 1; i <= MAX_NODE; i++) {
      vis_ConnectCoords (connect,1,&i,&x);
      vis_StateSetData (state,i,x);
   }
                   /* compress and save coordinate state */
   vis_ZStateState (zstate,state);
   vis_ZStateLngState (zstate,&nbytes);
   bstate = (Vuchar*)malloc(nbytes*sizeof(Vuchar));
   vis_ZStateSaveState (zstate,state,bstate,&newbytes);
   printf("State size= %lld bytes, actual= %lld\n",nbytes,newbytes);

                   /* clean-up ZState and State */
   vis_ZStateEnd (zstate);
   vis_StateEnd (state);

                   /* instance new ZState and State to reload */
   zstate = vis_ZStateBegin ();
   vis_ZStateSetObject (zstate,VIS_GRIDFUN,(Vobject*)gridfun);
   vis_ZStateLoadKernel (zstate,bkernel);
   state = vis_StateBegin ();
   vis_StateSetObject (state,VIS_GRIDFUN,(Vobject*)gridfun);
   vis_ZStateLoadState (zstate,bstate,state);

                   /* compare compressed and uncompressed values */
   for(i = 1; i <= MAX_NODE; i++) {
      vis_ConnectCoords (connect,1,&i,&x);
      printf("%5d, %11.4e %11.4e %11.4e, ",i,x[0],x[1],x[2]);
      vis_StateData (state,1,&i,x);
      printf("%11.4e %11.4e %11.4e\n",x[0],x[1],x[2]);
   }
                   /* clean-up */
   vis_ZStateEnd (zstate);
   vis_ConnectEnd (connect);
   vis_GridFunEnd (gridfun);
   vis_StateEnd (state);
   free (bstate);
   free (bkernel);
   return 0;
}

Table of Contents

25.47 Example 58vdm, Compress and Uncompress Results with ZState

This example illustrates using the ZState module to compress and uncompress nodal and element State data.

The example takes as its single argument any file supported by VdmTools. The VdmTools interface used is determined by the file extension (e.g., .op2). The Model is extracted from the file and a GridFun object is generated from the Connect object.

The example is divided into two steps. In the first, a nodal kernel is generated and all nodal states are compressed. In the second an element kernel is generated and all element states are compressed. For each of these steps a ZState object is instanced and configured. The kernel is then computed with vis_ZStateKernel and an upper bound limit on the memory required to save the kernel is returned in vis_ZStateLngKernel. This memory is then allocated and the kernel is saved with vis_ZStateSaveKernel, which returns the true amount of memory required to save the kernel. Then all nodal datasets are compressed in a similar manner, by first calling vis_ZStateState, followed by vis_ZStateLngState, and by vis_ZStateSaveState. In a typical usage the kernel and state memory are saved in external storage for later retrieval.

The example also demonstrates what would done in a separate program to perform the uncompression. vis_ZStateLoadKernel recreates the kernel and, for each State, vis_ZStateLoadState recreates the lossy State.

#include "base/system.h"
#include "base/base.h"
#include "vgl/vgl.h"
#include "vis/vis.h"
#include "vdm/vdm.h"
#include "vdm/exam/datafile.h"

/*----------------------------------------------------------------------
                   Compress and Uncompress Results with ZState
----------------------------------------------------------------------*/
int
main(int argc, char **argv)
{
   vis_ZState  *zstate;
   vis_Connect *connect;
   vis_GridFun *gridfun;
   vis_Model   *model;
   vis_State   *state;
   vis_RProp   *rprop;
   vdm_DataFun *datafun;
   vdm_LMan    *lman;
   vdm_Library *library;
   vdm_Dataset *dataset;
   vis_IdTran  *idtran;
   Vuchar *bkernel, *bstate;
   Vint filetype, ierr, numdatasets, numnp, numel, idst, i, j;
   Vint nodeinc, eleminc, pid;
   Vchar root[256], cqua[256], caux[256], dsname[DATASET_MAXNAME];
   Vint type, hist, nqua, iqua[SYS_NQUA_MAX], sect, enttype, subtype, cplx;
   Vint id1, id2, id3;
   Vlong lrec;
   Vint nrow, ncol, dtype;
   Vulong nbytes, newbytes;
   Vfloat value[100];
   Vfloat ratio;

   if(argc < 2) {
      fprintf(stderr,"Usage: %s results_file\n",argv[0]);
      return 1;
   }
                   /* open results file */
   datafiletype (argv[1],&filetype);
   if(filetype == 0) {
      fprintf(stderr,"Error: Bad input file %s\n",argv[1]);
      return 1;
   }
   datafun = vdm_DataFunBegin ();
   datafileinit (filetype,datafun);
   vdm_DataFunOpen (datafun,0,argv[1],filetype);
   ierr = vdm_DataFunError(datafun);
   if(ierr) {
      fprintf(stderr,"Error: opening file %s\n",argv[1]);
      return 1;
   }
   printf("Processing file= %s\n",argv[1]);
   vdm_DataFunNumDatasets (datafun,&numdatasets);
   vdm_DataFunGetLibrary (datafun,&library);

                   /* extract model/connect */
   lman = vdm_LManBegin ();
   vdm_LManSetObject (lman,VDM_DATAFUN,(Vobject*)datafun);
   model = vis_ModelBegin ();
   vdm_LManLoadModel (lman,model);
   vis_ModelGetObject (model,VIS_CONNECT,(Vobject**)&connect);
   vis_ConnectNumber (connect,SYS_NODE,&numnp);
   vis_ConnectNumber (connect,SYS_ELEM,&numel);
   printf("   numnp= %d\n",numnp);
   printf("   numel= %d\n",numel);
   nodeinc = numnp/10;
   if(nodeinc == 0) {
      nodeinc = 1;
   }
   eleminc = numel/10;
   if(eleminc == 0) {
      eleminc = 1;
   }

                   /* create GridFun */ 
   gridfun = vis_GridFunBegin ();
   vis_ConnectGridFun (connect,gridfun);

                   /* create State and RProp */
   rprop = vis_RPropBegin ();
   state = vis_StateBegin ();
   vis_StateSetObject (state,VIS_GRIDFUN,(Vobject*)gridfun);

                   /* create ZState and Def it for nodal data */ 
   zstate = vis_ZStateBegin ();
   vis_ZStateSetObject (zstate,VIS_GRIDFUN,(Vobject*)gridfun);

                   /* Setup for nodal results */
   vis_ZStateDef (zstate,numnp,SYS_NODE,SYS_NONE);

                   /* create ZState kernel and save it */ 
   vis_ZStateKernel (zstate,NULL);
   vis_ZStateLngKernel (zstate,&nbytes);
   printf("   Nodal kernel size= %lld bytes\n",nbytes);
   bkernel = (Vuchar*)malloc(nbytes*sizeof(Vuchar));
   vis_ZStateSaveKernel (zstate,bkernel,&newbytes);
   vis_ZStateEnd (zstate);

                   /* load ZState kernel */ 
   zstate = vis_ZStateBegin ();
   vis_ZStateSetObject (zstate,VIS_GRIDFUN,(Vobject*)gridfun);
   vis_ZStateLoadKernel (zstate,bkernel);
   free (bkernel);

                   /* loop over all nodal states */ 
   vis_RPropDef (rprop,SYS_NODE,SYS_NONE);
   for(idst = 0; idst < numdatasets; idst++) {
      vdm_LibraryGetDataset (library,idst,&dataset);
      vdm_DatasetResult (dataset,root,&type,&hist,&nqua,iqua,cqua,
                         &cplx,caux,§,&enttype,&subtype,
                         &id1,&id2,&id3);

      /* skip non-result datasets */
      if(type == SYS_RES_NONE)  continue;

      /* skip non-nodal results */
      if(enttype != SYS_NODE || subtype != SYS_NONE)  continue;

      /* load this nodal state */
      vdm_DatasetInq (dataset,dsname,&lrec,&nrow,&ncol,&dtype);
      printf("   Dataset= %s\n",dsname);
      vis_RPropSetDatasetName (rprop,dsname);
      vdm_LManLoadState (lman,state,rprop);
      printf("      Original values:\n");
      for(i = 1; i <= numnp; i += nodeinc) {
         vis_StateData (state,1,&i,value);
         printf("      %10d",i);
         for(j = 0; j < nrow; ++j) {
            printf(" %11.4e",value[j]);
         }
         printf("\n");
      }

                   /* compress and save coordinate state */
      vis_ZStateState (zstate,state);
      vis_ZStateLngState (zstate,&nbytes);
      printf("      Original   state size= %lld bytes\n",lrec*sizeof(Vfloat));
      printf("      Compressed state size= %lld bytes\n",nbytes);
      ratio = (Vfloat)((lrec*sizeof(Vfloat))/(Vfloat)nbytes);
      printf("      Compression ratio= %f\n",ratio);
      bstate = (Vuchar*)malloc(nbytes*sizeof(Vuchar));
      vis_ZStateSaveState (zstate,state,bstate,&newbytes);

                   /* clean-up ZState and State */
      vis_StateEnd (state);

                   /* instance new ZState and State to reload */
      state = vis_StateBegin ();
      vis_StateSetObject (state,VIS_GRIDFUN,(Vobject*)gridfun);
      vis_ZStateLoadState (zstate,bstate,state);
      free (bstate);

                   /* compare compressed and uncompressed values */
      printf("      Compressed values:\n");
      for(i = 1; i <= numnp; i += nodeinc) {
         vis_StateData (state,1,&i,value);
         printf("      %10d",i);
         for(j = 0; j < nrow; ++j) {
            printf(" %11.4e",value[j]);
         }
         printf("\n");
      }
   }
                   /* Setup for element results */
   vis_ZStateDef (zstate,numel,SYS_ELEM,SYS_NONE);

                   /* Create idtran and assign propid */
   idtran = vis_IdTranBegin ();
   vis_IdTranDef (idtran,numel);
   for(i = 1; i <= numel; ++i) {
      vis_ConnectElemAssoc (connect,VIS_PROPID,1,&i,&pid);
      vis_IdTranSetId (idtran,i,pid+1);
   }
                   /* create ZState kernel and save it */ 
   vis_ZStateKernel (zstate,idtran);
   vis_IdTranEnd (idtran);

   vis_ZStateLngKernel (zstate,&nbytes);
   printf("   Element kernel size= %lld bytes\n",nbytes);
   bkernel = (Vuchar*)malloc(nbytes*sizeof(Vuchar));
   vis_ZStateSaveKernel (zstate,bkernel,&newbytes);
   vis_ZStateEnd (zstate);

                   /* load ZState kernel */
   zstate = vis_ZStateBegin ();
   vis_ZStateSetObject (zstate,VIS_GRIDFUN,(Vobject*)gridfun);
   vis_ZStateLoadKernel (zstate,bkernel);
   free (bkernel);

                   /* loop over all element states */ 
   vis_RPropDef (rprop,SYS_ELEM,SYS_NONE);
   for(idst = 0; idst < numdatasets; idst++) {
      vdm_LibraryGetDataset (library,idst,&dataset);
      vdm_DatasetResult (dataset,root,&type,&hist,&nqua,iqua,cqua,
                         &cplx,caux,§,&enttype,&subtype,
                         &id1,&id2,&id3);

      /* skip non-result datasets */
      if(type == SYS_RES_NONE)  continue;

      /* skip non-element results */
      if(enttype != SYS_ELEM || subtype != SYS_NONE)  continue;

      /* load this nodal state */
      vdm_DatasetInq (dataset,dsname,&lrec,&nrow,&ncol,&dtype);
      printf("   Dataset= %s\n",dsname);
      vis_RPropSetDatasetName (rprop,dsname);
      vdm_LManLoadState (lman,state,rprop);
      printf("      Original values:\n");
      for(i = 1; i <= numel; i += eleminc) {
         vis_StateData (state,1,&i,value);
         printf("      %10d",i);
         for(j = 0; j < nrow; ++j) {
            printf(" %11.4e",value[j]);
         }
         printf("\n");
      }

                   /* compress and save coordinate state */
      vis_ZStateState (zstate,state);
      vis_ZStateLngState (zstate,&nbytes);
      printf("      Original   state size= %lld bytes\n",lrec*sizeof(Vfloat));
      printf("      Compressed state size= %lld bytes\n",nbytes);
      ratio = (Vfloat)((lrec*sizeof(Vfloat))/(Vfloat)nbytes);
      printf("      Compression ratio= %f\n",ratio);
      bstate = (Vuchar*)malloc(nbytes*sizeof(Vuchar));
      vis_ZStateSaveState (zstate,state,bstate,&newbytes);

                   /* clean-up ZState and State */
      vis_StateEnd (state);
      state = vis_StateBegin ();
      vis_StateSetObject (state,VIS_GRIDFUN,(Vobject*)gridfun);
      vis_ZStateLoadState (zstate,bstate,state);
      free (bstate);

                   /* compare compressed and uncompressed values */
      printf("      Compressed values:\n");
      for(i = 1; i <= numel; i += eleminc) {
         vis_StateData (state,1,&i,value);
         printf("      %10d",i);
         for(j = 0; j < nrow; ++j) {
            printf(" %11.4e",value[j]);
         }
         printf("\n");
      }
   }
   vdm_DataFunClose (datafun);

                   /* clean-up */
   vis_RPropEnd (rprop);
   vis_StateEnd (state);
   vis_ZStateEnd (zstate);
   vis_ModelDelete (model);
   vis_ModelEnd (model);
   vis_GridFunEnd (gridfun);
   vdm_LManEnd (lman);
   datafileterm (filetype,datafun);
   vdm_DataFunEnd (datafun);
   return 0;
}

Table of Contents

25.48 Example 59vgl, Demonstrate Parallel Contour and Threshold Generation

This example illustrates the generation of DList objects done in parallel with multiple processors.

A drawing window is opened and configured with OpenGL. Then VisContext, vis_Levels, and vis_ColorMap objects common to all threads are instanced and configured.

The PTask object is used to generate and run N threads simultaneously, where N is the number of processors available in the machine and is obtained using vut_MachInfoNumProc. Starting a thread requires an object per thread and a function to be executed. N parallel objects of type ParObj are then created. These will be used twice later on: to generate a display list using a Threshold object, then another display list using a Contour object. Note that each ParObj objects has its own instance of a Threshold and a Contour object as they will be executed simultaneously on different data.

The contour and threshold generation functions require that the Contour and Threshold objects are thread safe as well as the DrawFun and DList objects. It is also required that the Connect object query functions are const as well as the visualization attribute objects ColorMap, Levels and VisContext.

The example first generates a mesh containing both hexahedral and quadrilateral elements. The Threshold object only operates on 3D elements. The total number of 3D elements in the model is counted and equally divided among all processors. The IdTran object idtranthreshold is stored in each ParObj object and contains the list of elements that Threshold will operate on in each processor.

The Contour object operates on faces which are present in both 2D and 3D elements. Like in the Threshold usage above, the IdTran object idtrancontour stores the element and face number to be used in each processor by the Contour object. As in a typical application, only the free faces in the model are displayed by the Contour object.

The function vsy_PTaskExec is used twice, once to generate the display lists created by Threshold, and once to generate the display lists created by Contour. These lists are initially cleared with vgl_DListErase then serially displayed with vgl_DListCall.

#include "base/base.h"
#include "vgl/vgl.h"
#include "vis/vis.h"

static Vfloat rgb[6][3] = {
   {1.,0.,0.}, {0.,1.,0.}, {0.,0.,1.}, {0.,1.,1.}, {1.,0.,1.}, {1.,1.,0.} };

                   /* common parallel object */ 
typedef struct {
   Vint iproc;
   Vint nel;
   Vint nface;
   Vint numel;
   Vint numproc;
   vis_Threshold *threshold;
   vis_Contour   *contour;
   vgl_DList     *dl;
   vgl_DrawFun   *dfdl;
   vis_Connect   *connect;
   vis_IdTran    *idtranthreshold;
   vis_IdTran    *idtrancontour;
} ParObj;

#define NNODEX   101
#define NNODEY   101
#define NNODEZ   101
#define NELEMX   (NNODEX-1)
#define NELEMY   (NNODEY-1)
#define NELEMZ   (NNODEZ-1)

                   /* threshold generation function */ 
static void
gen_threshold(Vobject *obj)
{
   ParObj *par = (ParObj*)obj;
   Vfloat s[8], x[8][3];
   Vint nix, ix[8], i, n, id;
                   /* generate display list */
   vis_ThresholdSetTopology (par->threshold,SYS_SHAPEHEX,0,0,0);
   for(n = 1; n <= par->nel; ++n) {
      vis_IdTranGetId (par->idtranthreshold,n,&id);
      vis_ConnectElemNode (par->connect,id,&nix,ix);
      vis_ConnectCoords (par->connect,nix,ix,x);
      for(i = 0; i < nix; ++i) {
         s[i] = sqrt(x[i][0]*x[i][0]+x[i][1]*x[i][1]+x[i][2]*x[i][2]);
      }
      vis_ThresholdCurv (par->threshold,s,x,VIS_NODATA,NULL);
   }
}

                   /* threshold generation function */ 
static void
gen_contour(Vobject *obj)
{
   ParObj *par = (ParObj*)obj;
   Vfloat s[8], x[8][3];
   Vint nix, ix[8], i, n, id, no;
   Vint shape, maxi, maxj;

                   /* generate display list */
   for(n = 1; n <= par->nface; ++n) {
      vis_IdTranGetId (par->idtrancontour,n,&id);
      vis_IdTranGetEnt (par->idtrancontour,n,&no);
      vis_ConnectElemTopo (par->connect,SYS_FACE,id,no,&shape,&maxi,&maxj);
      vis_ContourSetTopology (par->contour,shape,maxi,maxj);

      vis_ConnectElemCon (par->connect,SYS_FACE,id,no,&nix,ix);
      vis_ConnectCoords (par->connect,nix,ix,x);
      for(i = 0; i < nix; ++i) {
         s[i] = sqrt(x[i][0]*x[i][0]+x[i][1]*x[i][1]+x[i][2]*x[i][2]);
      }
      vis_ContourCurv (par->contour,s,x,VIS_NODATA,NULL);
   }
}

                   /* serial drawing of display lists */ 
static void
draw_display(vgl_DrawFun *df, Vint numproc, ParObj **objs)
{
   Vint i, n;
   Vfloat tm[4][4];
   vgl_Xfm *xfm;

   xfm = vgl_XfmBegin ();
                   /* draw display lists */
   for(i = 0; i < 30; i++) {
      vgl_DrawFunClear (df);
      vgl_DrawFunXfmPush (df);
      vgl_XfmRotate (xfm,i*12.*.017453,XFM_XAXIS);
      vgl_XfmGetMatrix (xfm,tm);
      vgl_DrawFunXfmLoad (df,tm);
      for(n = 0; n < numproc; ++n) {
         vgl_DListCall (objs[n]->dl);
      }
      vgl_DrawFunXfmPop (df);
      vgl_DrawFunSwap (df);
      vgl_DrawFunDelay (df,1.);
   }

   vgl_XfmEnd (xfm);
}

static void
createMesh(vis_Connect *connect, Vint *numel)
{
   Vint i, j, k, ix[8], numnode, numelem, numnodehex;
   Vfloat dx, dy, dz, x[3];

   numnode = 0;
   numelem = 0;
   dx = 1./NELEMX;
   dy = 1./NELEMY;
   dz = 1./NELEMZ;
                   /* generate nodes for hex elements */
   for(k = 0; k < NNODEZ; ++k) {
      x[2] = k*dz;
      for(j = 0; j < NNODEY; ++j) {
         x[1] = j*dy;
         for(i = 0; i < NNODEX; ++i) {
            x[0] = i*dx;
            ++numnode;
            vis_ConnectSetCoords (connect,numnode,x);
         }
      }
   }
   numnodehex = numnode;

                   /* generate nodes for quad elements */
   x[2] = 0.;
   for(j = 0; j < NNODEY; ++j) {
      x[1] = j*dy;
      for(i = 0; i < NNODEX; ++i) {
         x[0] = i*dx - 1.;
         ++numnode;
         vis_ConnectSetCoords (connect,numnode,x);
      }
   }
                   /* generate hex elements */
   for(k = 0; k < NELEMZ; ++k) {
      for(j = 0; j < NELEMY; ++j) {
         for(i = 0; i < NELEMX; ++i) {
            ix[0] = NNODEX*NNODEY*k + NNODEX*j + i + 1;
            ix[1] = ix[0] + 1;
            ix[2] = ix[1] + NNODEX;
            ix[3] = ix[2] - 1;
            ix[4] = ix[0] + NNODEX*NNODEY;
            ix[5] = ix[1] + NNODEX*NNODEY;
            ix[6] = ix[2] + NNODEX*NNODEY;
            ix[7] = ix[3] + NNODEX*NNODEY;
            ++numelem;
            vis_ConnectSetTopology (connect,numelem,SYS_SHAPEHEX,0,0,0);
            vis_ConnectSetElemNode (connect,numelem,ix);
         }
      }
   }
                   /* generate quad elements */
   for(j = 0; j < NELEMY; ++j) {
      for(i = 0; i < NELEMX; ++i) {
         ix[0] = NNODEX*j + i + numnodehex + 1;
         ix[1] = ix[0] + 1;
         ix[2] = ix[1] + NNODEX;
         ix[3] = ix[2] - 1;
         ++numelem;
         vis_ConnectSetTopology (connect,numelem,SYS_SHAPEQUAD,0,0,0);
         vis_ConnectSetElemNode (connect,numelem,ix);
      }
   }
   vis_ConnectKernel (connect,0);
   *numel = numelem;
}

/*----------------------------------------------------------------------
                      Demonstrate Parallel Contour and Threshold Generation
----------------------------------------------------------------------*/
int
main()
{
   ParObj **objs;
#ifdef VKI_WIND_X11
   Display *display;
   int screen;
#endif

   vsy_PTask      *ptask;
   vgl_DrawFun    *df;
   vis_VisContext *vc;
   vis_Levels     *levels;
   vis_ColorMap   *cmap;
   vgl_OpenGLDev  *ogldev;
   vis_Connect    *connect;
   vis_Group      *group;

   int n, m, no, iproc;
   Vint nlevels;
   Vfloat c[3], x[3];
   Vint flag, numproc, numel;
   Vint nel, numparent, nfaces, nfproc, neproc;
   Vint shape, maxi, maxj, maxk;

                   /* generate mesh */
   connect = vis_ConnectBegin ();
   createMesh (connect,&numel);
   printf("mesh generation complete\n");
#ifdef VKI_WIND_X11
                   /* open X display */
   display = XOpenDisplay (0);
   screen = DefaultScreen (display);
   vgl_OpenGLDevConnectX (display,screen);
#endif
#ifdef VKI_WIND_WIN32
   vgl_OpenGLDevConnectWIN ();
#endif
                   /* create GL device */
   ogldev = vgl_OpenGLDevBegin ();

                   /* create draw function object for GL */
   df = vgl_DrawFunBegin ();
   vgl_OpenGLDevDrawFun (ogldev,df);

   vgl_DrawFunPositionWindow (df,200,200,400,400);
   vgl_DrawFunOpenWindow (df,"Example 59vgl");
   vgl_DrawFunProjOrtho (df,-2.,2.,-2.,2.,-2.,2.);
   vgl_DrawFunSetMode (df,VGL_ZBUFFERMODE,VGL_ON);
   vgl_DrawFunSetMode (df,VGL_LIGHTMODE,VGL_ON);
   c[0] = .4; c[1] = .4; c[2] = .4;
   x[0] = 0.; x[1] = 0.; x[2] = 0.;
   vgl_DrawFunLight (df,0,LIGHT_AMBIENT,c,x);
   c[0] =  .6;  c[1] =  .6;  c[2] =  .6;
   x[0] =  1.;  x[1] =  1.;  x[2] =  1.;
   vgl_DrawFunLight (df,1,LIGHT_DISTANT,c,x);
   x[0] = -1.;  x[1] = -1.;  x[2] = -1.;
   vgl_DrawFunLight (df,2,LIGHT_DISTANT,c,x);

                   /* vis context and set attributes */
   vc = vis_VisContextBegin ();

                   /* levels, set three evenly spaced levels */
   levels = vis_LevelsBegin ();
   nlevels = 5;
   vis_LevelsDef (levels,LEVELS_LINEAR,nlevels);
   vis_LevelsSetMinMax (levels,0.,1);
   vis_LevelsGenerate (levels,LEVELS_PADENDS);

                   /* color map */
   cmap = vis_ColorMapBegin ();
   vis_ColorMapSetType (cmap,COLORMAP_TRUECOLOR);
   vis_ColorMapSetRGB  (cmap,nlevels+1,0,rgb);

                   /* retrieve number of processors */
   vut_MachInfoNumProc (&flag,&numproc);
   if(!flag) {
      numproc = 1;
   }
                   /* instance PTask object for parallelization tasks */
   ptask = vsy_PTaskBegin ();
   vsy_PTaskInit (ptask,numproc);

                   /* instance parallel objects */
   objs = (ParObj**)vut_mallocMem(numproc*sizeof(ParObj**));
   for(iproc = 0; iproc < numproc; iproc++) {
      objs[iproc] = (ParObj*)vut_mallocMem(sizeof(ParObj));
      objs[iproc]->iproc   = iproc;
      objs[iproc]->connect = connect;
      objs[iproc]->numel   = numel;
      objs[iproc]->numproc = numproc;
                   /* create threshold DList and its DrawFun */
      objs[iproc]->dl = vgl_DListBegin ();
      objs[iproc]->dfdl = vgl_DrawFunBegin ();
      vgl_DListDrawFun (objs[iproc]->dl,objs[iproc]->dfdl);
      vgl_DListSetObject (objs[iproc]->dl,VGL_DRAWFUN,df);

                   /* create threshold object and set objects */
      objs[iproc]->threshold = vis_ThresholdBegin ();
      vis_ThresholdSetObject (objs[iproc]->threshold,VGL_DRAWFUN,
                              objs[iproc]->dfdl);
      vis_ThresholdSetObject (objs[iproc]->threshold,VIS_VISCONTEXT,vc);
      vis_ThresholdSetObject (objs[iproc]->threshold,VIS_LEVELS,levels);
      vis_ThresholdSetObject (objs[iproc]->threshold,VIS_COLORMAP,cmap);

                   /* create list of threshold elements for this processor */
      objs[iproc]->idtranthreshold = vis_IdTranBegin ();

                   /* create contour object and set objects */
      objs[iproc]->contour = vis_ContourBegin ();
      vis_ContourSetObject (objs[iproc]->contour,VGL_DRAWFUN,
                            objs[iproc]->dfdl);
      vis_ContourSetObject (objs[iproc]->contour,VIS_VISCONTEXT,vc);
      vis_ContourSetObject (objs[iproc]->contour,VIS_LEVELS,levels);
      vis_ContourSetObject (objs[iproc]->contour,VIS_COLORMAP,cmap);

                   /* create list of contour faces for this processor */
      objs[iproc]->idtrancontour = vis_IdTranBegin ();
      vis_IdTranSetEntType (objs[iproc]->idtrancontour,SYS_ELEM,SYS_FACE);
   }
                   /* count list of 3D elements for threshold */
   nel = 0;
   for(n = 1; n <= numel; ++n) {
      vis_ConnectTopology (connect,n,&shape,&maxi,&maxj,&maxk);
      if(shape == SYS_SHAPEHEX) {
         ++nel;
      }
   }
                   /* populate list of 3D elements for threshold */
   iproc = 0;
   m = 0;
   neproc = nel / numproc;
   for(n = 1; n <= numel; ++n) {
      vis_ConnectTopology (connect,n,&shape,&maxi,&maxj,&maxk);
      if(shape != SYS_SHAPEHEX)  continue;

      ++m;
      vis_IdTranSetId (objs[iproc]->idtranthreshold,m,n);

      /* check whether to populate next processor */
      if(m == neproc && iproc != numproc-1) {
         objs[iproc]->nel = neproc;
         m = 0;
         ++iproc;
      }
   }
   objs[numproc-1]->nel = m;

                   /* generate free faces */
   group = vis_GroupBegin ();
   vis_GroupDef (group,numel,SYS_ELEM,SYS_FACE);
   vis_ConnectFaceGroup (connect,CONNECT_FREE,NULL,group);
                   /* count list of faces for contour */
   vis_GroupCount (group,&numparent,&nfaces);
                   /* populate list of contour faces */
   iproc = 0;
   m = 0;
   nfproc = nfaces / numproc;
   for(n = 1; n <= numel; ++n) {
      for(no = 1; no <= 6; ++no) {
         if(vis_GroupElemEnt(group,n,no) == 0)  continue;

         ++m;
         vis_IdTranSetId (objs[iproc]->idtrancontour,m,n);
         vis_IdTranSetEnt (objs[iproc]->idtrancontour,m,no);

         /* check whether to populate next processor */
         if(m == nfproc && iproc != numproc-1) {
            objs[iproc]->nface = nfproc;
            m = 0;
            ++iproc;
         }
      }
   }
   objs[numproc-1]->nface = m;
   printf("parallel objects complete\n");

                   /* erase display list (actually not needed first time) */
   for(n = 0; n < numproc; ++n) {
      vgl_DListErase (objs[n]->dl);
   }
                   /* generate threshold display list */
   printf("begin threshold generation\n");
   vis_VisContextSetIsoValType (vc,VIS_ISOVALSURFACE);
   vsy_PTaskExec (ptask,numproc,gen_threshold,(Vobject*)objs,
                  PTASK_MODE_PARALLEL);
   printf("thresold generation complete\n");

                   /* draw threshold isosurfaces */ 
   draw_display (df,numproc,objs);

                   /* erase display list */
   for(n = 0; n < numproc; ++n) {
      vgl_DListErase (objs[n]->dl);
   }
                   /* generate contour display list */
   printf("begin contour generation\n");
   vis_VisContextSetIsoValType (vc,VIS_ISOVALFRINGE);
   vsy_PTaskExec (ptask,numproc,gen_contour,(Vobject*)objs,
                  PTASK_MODE_PARALLEL);
   printf("contour generation complete\n");

                   /* draw contoured surfaces */ 
   draw_display (df,numproc,objs);

                   /* close window */ 
   vgl_DrawFunCloseWindow (df);

                   /* free all objects */ 
   vgl_DrawFunEnd    (df);
   vis_VisContextEnd (vc);
   vis_LevelsEnd     (levels);
   vis_ColorMapEnd   (cmap);
   vgl_OpenGLDevEnd  (ogldev);
   vsy_PTaskTerm     (ptask);
   vsy_PTaskEnd      (ptask);
   vis_ConnectEnd    (connect);
   vis_GroupEnd      (group);
   for(n = 0; n < numproc; ++n) {
      vgl_DListEnd (objs[n]->dl);
      vgl_DrawFunEnd (objs[n]->dfdl);
      vis_ThresholdEnd (objs[n]->threshold);
      vis_ContourEnd (objs[n]->contour);
      vis_IdTranEnd (objs[n]->idtranthreshold);
      vis_IdTranEnd (objs[n]->idtrancontour);
      vut_freeMem (objs[n]);
   }
   vut_freeMem (objs);

                   /* disconnect from window system */
   vgl_OpenGLDevDisconnect ();

                   /* close X display */
#ifdef VKI_WIND_X11
   XCloseDisplay (display);
#endif
   return 0;
}