Mesh Import API

CFX-5 Reference Guide
Master Master Help On

Contents Index Help
Import Mesh API
• Introduction to the Import Mesh API p. 58
• Creating your own Mesh Import Program p. 59

• Linking your Code into CFX-5 p. 65
• Using your Custom Import Format p. 68
• API Functions p. 69
• Import Programs p. 82
Page 57 CFX-5.7.1
Mesh Import API
Contents Index Help
Introduction to the Import Mesh API

The Import Mesh Application Programming Interface allows you to build your own import
mesh program using a set of utility subroutines. The API has been provided for those users
who require mesh import capabilities beyond those available through the normal Import
Mesh forms in CFX-Pre.
Valid Mesh Elements in CFX-5

The CFX-Solver can solve flows in any mesh comprising one or more of the following
element types:
Tetrahedral Pyramidal
Prismatic (Wedge) Hexahedral
Your custom interface can be developed to support these element types allowing hybrid
meshes to be imported and used by CFX-5.
Page 58 Introduction to the Import Mesh API CFX-5.7.1

Mesh Import API
Contents Index Help
Creating your own Mesh Import Program

You can create your own customised Import Mesh program using the C programming
language. Several mesh import utility routines are provided as libraries with the CFX-5
installation for you to incorporate into your own programs. You can also use one of the
existing Import Mesh source routines as the basis of your custom mesh import program.
The basic structure of the API is common in all of the examples:
• Include cfxImport.h header file.
• Initialise for import with the cfxImportInit routine.
• Define node data with cfxImportNode.
• Define element data with cfxImportElement.
• Optionally define 2D and 3D regions with cfxImportRegion or cfxImportBegReg or
cfxImportAddReg and cfxImportEndReg.
• Finish the import and transfer data with cfxImportDone.
The utility routine libraries are located in
<CFXROOT>/lib/<os>/
where <CFXROOT> is the directory in which CFX is installed and <os> is the operating
system (e.g. solaris). More information on how to find out what these are for your system
can be found in Document Conventions (p. 3 in CFX-5 Installation).
See API Functions (p. 69) for more details.
The header files for the definition of the utility routines are located in
<CFXROOT>/include/
The header file cfxImport.h should be included in your import program to define the API
routines.
After creating the program, you will need to link it with the API routine libraries and run it
through CFX-Pre. See Linking your Code into CFX-5 (p. 65) and Using your Custom
Import Format (p. 68) for more details.
Note: Windows users should note that custom mesh import or export programs must be compiled as multi-
threaded applications.
A Custom Mesh Import Example

The following is an annotated listing of sections of the C source code for the Patran import
option. The full source code is available for use as a template and is located in
<CFXROOT>/examples/ImportTemplate.c.
Page 59 Creating your own Mesh Import Program CFX-5.7.1

Mesh Import API
Contents Index Help
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h> Specify the inclusion of header files which
#include <math.h> define functions required for the custom import.
#include <sys/types.h> These files should always be included, and this
#include <sys/stat.h> section should be at the beginning of your
custom coding.
#include "cfxImport.h"
static char options[] = "velF:";
static char *usgmsg[] = {

"usage : ImportPatran [options] Patran_file",
"options:", Define the
" -v = verbose output", import
options.
" -l = process packet 6 - distributed loads",
NULL
void main (argc, argv)

int argc;
char *argv[];
{
int n, packet, nlines;
int nnodes, elemid, nodeid[8]; Define the main program variables
int lastid = -1, loadid; including the array to hold the x,y,z
int verbose = 0, do_loads = 0; coordinates of the nodal locations.
double xyz[3];
char *p, buffer[256];
char *testfile = NULL;
FILE *fp;

Mesh Import API
Contents Index Help
while ((n = getargs (argc, argv, options)) > 0) {

switch (n) {
case 'v':
verbose = 7;
break;
case 'l':
do_loads = 1;
break; Filter command line
case 'F': arguments for the
testfile = argarg; import program.
break;
while (packet != 99) { Loop through all the packets
/* node */
Import nodes
if (packet == 1) { (packet 01)
if (0 != (verbose & 4)) {
printf ("reading packet 01 (nodes)...\n");
fflush (stdout);
verbose &= 3;
}
*nodeid = atoi (&buffer[2]);
getline ();
p = buffer + 48;
for (n = 2; n >= 0; n--) {
*p = 0;
p -= 16;
xyz[n] = atof (p);
}
getline ();

Mesh Import API
Contents Index Help
/* element */
else if (packet == 2) {
if (0 != (verbose & 2)) { Import elements
printf ("reading packet 02 (elements)...\n"); (packet 02)
fflush (stdout);
verbose &= 1;
}
elemid = atoi (&buffer[2]);
n = atoi (&buffer[10]);
nlines = atoi (&buffer[18]);
if (n == 5 || n == 7 || n == 8) {
getline ();
nnodes = n == 8 ? n : n-1;
lineno++;
for (n = 0; n < nnodes; n++) {
if (1 != fscanf (fp, "%d", &nodeid[n]) ||
nodeid[n] < 1)
cfxImportFatal ("missing or invalid node
ID");
}
while (getc (fp) != '\n')
;
nlines -= 2;
cfxImportElement (elemid, nnodes, nodeid);

Mesh Import API
Contents Index Help
/* distributed loads */
else if (packet == 6 && do_loads) {

elemid = atoi (&buffer[2]); Import loads
loadid = atoi (&buffer[10]); (packet 06)
nlines = atoi (&buffer[18]);
if (loadid != lastid) {
sprintf (buffer, "PatranLoad%d", loadid);
if (verbose) {
printf ("reading packet 06 (loads) as region
<%s>...\n",
buffer);
fflush (stdout);
}
cfxImportBegReg (buffer, cfxImpREG_NODES);
lastid = loadid;
}
getline ();
/* add if element load flag is set */
if ('1' == buffer[0])
add_face (elemid, &buffer[9]);
Finish import
/* finish up and send the data */
if (verbose) {
printf ("transferring data...\n");
fflush (stdout);
}
cfxImportDone ();

Mesh Import API
Contents Index Help
/* print summary */ Print a summary of the import
if (verbose) {
int stats[cfxImpCNT_SIZE];
long bytes;
static char *statname[] = {
"imported nodes ",
"imported elements ",
"imported regions ",
"unreferenced nodes",
"duplicate nodes ",
"tet elements ",
"pyramid elements ",
"wedge elements ",
"hex elements ",
"total bytes sent "
};
bytes = cfxImportTotals (stats);
putchar ('\n');
for (n = 0; n < 9; n++)
printf ("%s = %d\n", statname[n], stats[n]);
printf ("%s = %ld\n", statname[9], bytes);
}

Mesh Import API
Contents Index Help
Linking your Code into CFX-5

In order to build an import utility routine, it must be linked with the Import API library. The
library is named libmeshimport.a on UNIX and libmeshimport.lib on Windows
platforms.
Compiler Flags
The following compiler flags are necessary for successful compilation on the listed
platforms:
Platform Flag
hpux (pa-2) +DS2.0W +DA2.0W
hpux-ia64 +DD64
linux (32 bit) <none>
linux-ia64 <none>, but use ecc compiler
irix -64
solaris -xarch=v9
aix -q64 (the linker may also need -
b64)
UNIX
On most UNIX systems you should be able to build the executable with the command:
cc myimport.c -l<CFXROOT>/include/ -o myimport -L<CFXROOT>/lib/<os> -
lmeshimport -lio -lm -lc
Note that some platforms use different compilers (e.g. xlc on AIX and ecc on Linux IA64).
where <CFXROOT> is the directory in which CFX is installed, and <os> is the architecture
of the machine that you are running on (e.g. one of solaris, irix, hpux, hpux-ia64,
aix, linux, linux-ia-64). To find out what <CFXROOT> is for your installation, see
Specific Directory Names (p. 4 in CFX-5 Installation). To find out what <os> is for your
machine, see Operating System Names (p. 5 in CFX-5 Installation). In this example, your
own import program is named myimport.c and the executable file will be called
myimport.
You should ensure that the libraries that you are linking to (the path given after -L) appear
on the command line after the source file (or object file if you are just linking to an existing
object).
Page 65 Linking your Code into CFX-5 CFX-5.7.1
Mesh Import API
Contents Index Help
Windows
On Windows systems, assuming that you are using the Microsoft Developer Studio which
comes with Visual C++ version 6 or .NET, you can do the following to build your executable:
Visual C++ 6
1. Create a new project by selecting File > New, which should be a Win32 Console
Application.
2. Specify the libraries which need to be linked in, by selecting Project > Add to Project >
Files. Add Library Files libio.lib and libmeshimport.lib from the
<CFXROOT>\lib\winnt directory, where<CFXROOT> is the directory in which CFX is
installed.
3. Specify the header files which need to be included, by selecting Project > Settings.
Select Settings for: All Configurations and the C/C++ tab, and select the
Preprocessor category. You need to add the Additional Include Directory
<CFXROOT>\include\.
4. Next, you should create your C++ source file. Select New > C++ source file, and copy
your C++ source file into the window for this file.
5. Before building the executable, you must choose to ignore the standard C and LIBCD
libraries. To do this: under Project Settings, click on the Link tab and enter C,LIBCD in
the Ignore Libraries box.
6. You must also compile with multithreading ON. Under Project Settings, click on the C/
C++ tab, select Code Generation from the Category option menu, and select
Multithreaded DLL from the Use run-time Library option menu.
7. To build the executable, select Build > Build <program_name>.exe, where
<program_name> is the name of the project.
.NET
1. Create a new project by selecting File > New, which should be a Win32 Console
Application.
2. Specify the libraries which need to be linked in, by selecting
Project > Add existing item. Change Files of Type to *.* so that the .lib files are not
filtered out.
3. Specify the header files which need to be included, by selecting
Project > <program_name> Properties > C/C++ > Additional Include directives
(where <program_name> corresponds to the name of your project).

Mesh Import API
Contents Index Help
4. Next, you should create your C++ source file. When the project is created, three source
files stdafx.h stdafx.cpp and <program_name>.cpp are created.
<program_name>.cpp includes stdafx.h and has a function _tmain(). Delete the
contents of this file, then:
(a) Add the following lines to the start of the file
#include "stdafx.h"
#define PROTOTYPE1 to the beginning of the file.
(b) Paste in your mesh import source code and rename the main() function to
_tmain().
5. Before building the executable, you must choose to ignore the standard C and LIBCD
libraries. To do this: set Project > <program_name> Properties > Linker > Input >
Ignore Specific Library to C LIBCD.
6. You must also compile with multithreading ON. Select
.Project > <program_name> Properties > C/
C++ >Code Generation > Runtime Library to Multithreaded DLL.
7. To build the executable, select Build > Build <program_name>.exe.

Mesh Import API
Contents Index Help
Using your Custom Import Format
Running the program from CFX-Pre

To access your routine, you need to select the mesh file to import on the Mesh Import
Editor (p. 88 in CFX-Pre) form and set the Mesh Format to User Import. When this option
is selected, you should select the Advanced tab, enter the name of your compiled program
into the box marked Exec Location and enter any command line arguments that your
program requires into the Exec Arguments box. When OK is pressed your program will be
called with the syntax
<User’s Import Executable> <Executable Arguments> <Mesh file>
Alternatively, to specify the executable program every time you start CFX-Pre, you can add
the following line to your .cfx5rc file:
CFX_IMPORT_EXEC="<executable_path>"
where <executable_path> is the full path and name of your executable. See Resources
Set in cfx5rc Files (p. 84 in CFX-5 Installation) for more details on .cfx5rc files.
When you next use the User Import option for importing a mesh, the form will appear with
the name of your executable in the User’s Import Executable databox.
Page 68 Using your Custom Import Format CFX-5.7.1

Mesh Import API
Contents Index Help
API Functions
This section lists the various routines available through the Mesh Import API that are
available when you write your own customised program. A description of how to use the
Import Mesh API is given in Creating your own Mesh Import Program (p. 59), and this
includes information on how to write a customised Import Mesh program, how to link it into
CFX-5, and how to run it. The locations of all the necessary files and libraries and an
example are described in this document, and you are recommended to read it before trying
to use any of the routines listed here.
Defined Constants
The following are defined in the header file cfxImport.h, which should be included in the
import program.
Element Types
There are currently 4 types of elements, which are identified by the number of nodes:
Tetrahedrons (4 nodes), pyramids (5 nodes), wedges or prisms (6 nodes), and
hexahedrons (8 nodes). The element types may be identified by the defined constants:
#define cfxELEM_TET 4
#define cfxELEM_PYR 5
#define cfxELEM_WDG 6
#define cfxELEM_HEX 8
The element node ordering and local face numbering follow Patran Neutral file conventions
for element descriptions.
Region Types
Regions may be defined in terms of nodes, faces or elements, based on the type argument
to the cfxImportBegReg or cfxImportRegion routines. The three types are defined by
the defined constants:
#define cfxImpREG_NODES 1
#define cfxImpREG_FACES 2
#define cfxImpREG_ELEMS 3
Node and Face regions define 2D regions of the imported mesh. Element regions define 3D
regions of the imported mesh.
It is best to use face regions to define 2D regions of the mesh and element regions to define
3D regions of the mesh.
Page 69 API Functions CFX-5.7.1

Mesh Import API
Contents Index Help
Node regions will be automatically transformed into a face region by the import process.
This transformation requires the node ID’s specified to define vertices of valid element
faces. If no element faces can be constructed from the defined node region the node region
will be deleted.
Note: Due to the limited topological information recoverable from a set of nodes it is not advisable to define
2D regions internal to a 3D region using nodes. In this case it is advisable to use Face regions.
Node regions are specified by a list of node ID’s.

Face regions are defined by a list of face ID’s. These face ID’s are a combination of an
element ID and a local face number in the element. The following macro is provided in
cfxImport.h to construct the face ID:
#define cfxFACEID(elemid,facenum) ((elemid<<3)|(facenum&7))
In Fortran, the same operation may be done as:
faceid = 8 * elemid + facenum
Element regions are specified as a list of element ID’s.
Initialisation Routines
The following routines check and initialise the Import API. With the exception of
cfxImportStatus the first call to the Import API must be either cfxImportInit for
communication with CFX-5, or cfxImportTest for testing the import routine in stand-
alone mode.
cfxImportStatus
int cfxImportStatus ()
Checks the current status of the connection to CFX-5 based on the state of the file
descriptor associated with a communication channel.
Returns 0 if descriptor is not opened and -1 if not opened for writing. In the normal case, 1
is returned if opened for writing to a CFX-5, and 2 if opened for writing to a file.
cfxImportInit
void cfxImportInit ()
Performs initialisation to begin communicating with CFX-5. This routine should be called
early on in the import program to let CFX-5 know that data is to be sent. If not called within
60 seconds, CFX-5 will terminate the import process. If called and there is no connection
with CFX-5, then the routine cfxImportTest("/dev/null") (UNIX) or
cfxImportTest("null") (Windows) will be called. This routine will be automatically
called by most of the API routines if not already called.

Mesh Import API
Contents Index Help
There is no return value for this routine. In the case of an error, cfxImportFatal will be
called.
cfxImportTest
int cfxImportTest (filename)
char *filename;
This routine allows testing of import program in isolation from CFX-5 by writing data to a file
filename instead of attempting to write it to the CFX-5 communication channel.
The routine will return the file descriptor of the output file or will terminate with a call to
cfxImportFatal on error.
Termination Routines
With the exception of cfxImportTotals the last call to the Import API must always be
cfxImportDone. This function performs the final processing of the import data, and then
transfers the data to CFX-5.
cfxImportDone
long cfxImportDone ()
Indicate to the import API that all mesh data has been given and the API should now send
the data to CFX-5. Except for cfxImportTotals, this should be last call made to the API.
Returns the total number of bytes transferred to CFX-5 by the import program.
cfxImportTotals
long cfxImportTotals (counts)
int counts[cfxImpCNT_SIZE];
Get the total number of nodes, elements, regions and other useful information given to the
mesh import API by the program. This information is returned in the array counts, which
should be of size at least cfxImpCNT_SIZE (currently defined as 9). The values returned
in counts may be indexed by the enum list in cfxImport.h, which is:
counts[cfxImpCNT_NODE] = number of nodes
counts[cfxImpCNT_ELEMENT] = number of elements
counts[cfxImpCNT_REGION] = number of regions
counts[cfxImpCNT_UNUSED] = number of unused nodes
counts[cfxImpCNT_DUP] = number of duplicate nodes
counts[cfxImpCNT_TET] = number of tetrahedral elements
counts[cfxImpCNT_PYR] = number of pyramid elements
counts[cfxImpCNT_WDG] = number of wedge elements
counts[cfxImpCNT_HEX] = number of hexahedral elements

Mesh Import API
Contents Index Help
The return value for the function is the total number of bytes of data sent to CFX-5 or written
to the test file given when cfxImportTest was called.
Error Handling Routines

The following two routines allow the programmer to define an error callback function, and a
termination routine which terminates the import process cleanly.
cfxImportError
void cfxImportError (callback)
void (*callback)(char *errmsg);
Define a user routine to be called before terminating due to a fatal error. callback is the
application-supplied function to be called in the case of an error. The callback routine takes
a single argument, errmsg, which will be passed by cfxImportFatal and should be
processed by the callback function as a brief message describing the error that has
occurred,. If this function is not called or callback is not specified, then the normal
termination behaviour of the import mesh API will be that the any fatal errors will write the
error message to stderr as well as being sent to CFX-5.
cfxImportFatal
void cfxImportFatal (errmsg)
char *errmsg;
Terminate with an error message, errmsg. This routine will send the message to CFX-5,
shut down the communication channel or test file and call the user callback function (if
specified by a call to cfxImportError).
There is no return from this call. The import program will terminate immediately after clean
up tasks have been performed.
Node Routines
These routines define the 3D coordinates of points in space(nodes) which will be used to
define elements or 2D regions which are to be imported to CFX-5. Each node has a unique
identifier called a node ID.
cfxImportNode
int cfxImportNode (nodeid, x, y, z)
int nodeid;
double x, y, z;

Mesh Import API
Contents Index Help
Define a node in the import API to be subsequently imported into CFX-5. The unique
identifier of the node is given by nodeid, and the coordinates of the node by x, y, and z.
Returns 0 if nodeid is invalid (less than 1), -1 if the node had already been defined (in which
case the node is redefined using the new coordinates), or nodeid if successfully defined.
cfxImportGetNode
int cfxImportGetNode (nodeid, x, y, z)
int nodeid;
double *x, *y, *z;
Get the coordinates for the node identified by nodeid and return the values in x, y, and z.
Returns 0 if the node has not been defined or the node ID for the node.
cfxImportNodeList
int * cfxImportNodeList ()
Returns an array of all node identifiers currently defined or NULL if no nodes have been
defined. The first entry in the array is the number of nodes currently defined.
The memory for the array returned is allocated using malloc by the routine, consequently
it should be destroyed when no longer required by calling free.
Element Routines
The following routines define the topology of elements (using node ID’s) which are to be
imported to CFX-5. Also included here are routines which get the local face number and
vertices of an element.
cfxImportElement
int cfxImportElement (elemid, elemtype, nodelist)
int elemid, elemtype, *nodelist;
Define a new element to be imported to CFX-5. The unique identifier of the element is given
by elemid, the element type by elemtype and the list of vertices by nodelist. If an
element with the same ID has already been defined, it will be replaced by the new element
being defined.
Only volume elements are currently supported by CFX-5; these may be tetrahedrons (4
vertices), pyramids (5 vertices), prisms (6 vertices) or hexahedrons (8 vertices). elemtype
is the number of vertices for the element.
The following defines are included in the header file, cfxImport.h for convenience:
#define cfxELEM_TET 4 /* tet element (4 nodes ) */
#define cfxELEM_PYR 5 /* pyramid element (5 nodes ) */

Mesh Import API
Contents Index Help
#define cfxELEM_WDG 6 /* wedge element (6 nodes) */
#define cfxELEM_HEX 8 /* hex element (8 nodes) */
The list of vertices in nodelist refers to ID’s of nodes which on termination of the import
program by a call to cfxImportDone must have been defined by calls to
cfxImportNode. If this is not the case a fatal error will be reported and the API will
terminate.
The vertex ordering for the elements follows Patran Neutral File element conventions, and
is shown in the following figure.
5
4
3 4
2 3
1
1
2
Tetrahedron Pyramid
6 8
7
5 5
6
4 4
3
3
2 1
2
1 Prism Hexahedron
Returns 0 in the case of an elemid is invalid (less than 1) or an unsupported value is given
by elemtype, -1 if the element already exists and has been redefined , or elemtype if the
element is successfully defined.
cfxImportGetElement
int cfxImportGetElement (elemid, nodelist)
int elemid, nodelist[];

Mesh Import API
Contents Index Help
Get the node ID’s for corresponding to the vertices of element identified by elemid and
store in the array nodelist. This array needs to be at least as large the number of vertices
for the element (a size of 8 will handle all possible element types).
Returns 0 if the element is not defined, or the element type (number of vertices). The node
ID’s will be ordered in the order expected by cfxImportElement if the program was to
redefine the element.
cfxImportElementList
int * cfxImportElementList ()
Returns an array of all the currently defined element ID’s or NULL if no elements have been
defined. The first entry in the array is the number of elements.
The memory for the array returned is allocated using malloc by the routine, consequently
it should be destroyed when no longer required by calling free.
cfxImportGetFace
int cfxImportGetFace (elemid, facenum, nodelist)
int elemid, facenum, nodelist[];
Gets the node ID’s for the local facenum’th face of the element identified by elemid.
The node ID’s is returned in nodelist, which should be of at least of size 4. The nodes
correspond to the vertices of the face and are ordered counter-clockwise such that the
normal for the face points away from the element. The face numbers, and associated node
indices follows Patran Neutral File element and are detailed in the following table:
Element Type Face Nodes
tetrahedron 1 1 3 2
2 1 2 4
3 2 3 4
4 1 4 3
pyramid 1 1 4 3 2
2 1 2 5
3 2 3 5
4 3 4 5
5 1 5 4
prism 1 1 3 2

Mesh Import API
Contents Index Help
Element Type Face Nodes
2 4 5 6
3 1 2 5 4
4 1 4 6 3
5 2 3 6 5
hexahedron 1 1 2 6 5
2 3 4 8 7
3 1 4 3 2
4 2 3 7 6
5 5 6 7 8
6 1 5 8 4
Returns -1 if the element has not been defined, 0 if the face number is out of range, or the
number of nodes for the face (3 or 4):
cfxImportFindFace
int cfxImportFindFace (elemid, nnodes, nodeid)
int elemid, nnodes, nodeid[];
Gets the local face number in element identified by elemid that contains all the nodes
supplied by the calling routine in nodeid. nnodes is the number of nodes for the face (3 or
4).
Returns -1 if the element is not found or nodeid is not supplied or nnodes is greater than
4 or less than 3. Returns 0 if there is no match, or the local face number (1 to 6) of the
element.
Primitive Region Routines

The following routines allow for the specification of 2D regions as a group of nodes or faces,
or a 3D region as a group of elements. In the case of nodes and faces, only those which are
define faces of valid imported elements will be imported; others are ignored by CFX-5.
cfxImportBegReg
int cfxImportBegReg (regname, regtype)
char *regname;
int regtype;

Mesh Import API
Contents Index Help
Initialise for the specification of a region. If a region is currently being defined,
cfxImportEndReg will be called.
The name of the region is given by regname. If the region name is NULL, the name
Unnamed Region 2D or Unnamed Region 3D, with a sequential integer appended, will
be used. If a region named regname has already been defined, then additional objects will
be added to the previous region.
The type of region is given by regtype, which should be one of cfxImpREG_NODES,
cfxImpREG_FACES or cfxImpREG_ELEMS depending on whether the region is to be
defined by nodes, faces or elements, respectively. It is not currently possible to mix types
in a region; doing so will cause the import API to terminate with an error message.
Returns the number of objects (node, faces or elements) currently in the region.
cfxImportAddReg
int cfxImportAddReg (numobjs, objlist)
int numobjs, *objlist;
Add ID’s of objects being defined to the current region.
A region must be currently defined or reactivated by cfxImportBegReg or an error will
occur, and the API will terminate.
The number of objects to add is given by numobjs and the ID’s of the objects are supplied
in objlist.
The objects are interpreted as node ID’s, face ID’s, or element ID’s, depending on the type
of the region indicated when cfxImportBegReg was called.
On calling cfxImportDone, any node ID’s , face ID’s or element ID’s specified in the object
list must have been defined by the appropriate routine or they will be removed from the
region.
Returns the total number of objects in the current region after the object ID’s have been
added.
cfxImportEndReg
int cfxImportEndReg ()
End the specification of the current region.
Returns the number of objects (nodes, faces or elements) in the region.
cfxImportRegion
int cfxImportRegion (regname, regtype, numobjs, objlist)
char *regname;
int regtype, numobjs, *objlist;
Mesh Import API
Contents Index Help
Import a region named regname of type regtype. The number of objects to add to the
region is given by numobjs, and the list of object ID’s by objlist. This routine combines
calls to cfxImportBegReg, cfxImportAddReg and cfxImportEndReg.
Returns the total number of objects in the region on termination of the routine.
cfxImportRegionList
char ** cfxImportRegionList ()
Return a NULL terminated list of currently defined region names.
The memory for the array and each character string in the array returned is allocated using
malloc by the routine, consequently each array member and the array itself should be
destroyed when no longer required by calling free.
cfxImportGetRegion
int * cfxImportGetRegion (regname)
char *regname;
Returns a list of objects in the region named regname, or NULL if the region does not exist.
The first entry in the returned list is the region type and the second entry is the number of
object ID’s.
The memory for the array is allocated using malloc by the routine, consequently the array
itself should be destroyed when no longer required by calling free.
Composite Regions Routines

The following routines allow composite regions to be defined in terms of regions referring to
object ID’s or other composite regions.
cfxImportBegCompRegion
cfxImportBegCompReg()
char *regionName;
Begin defining a composite region with the name regionName,
Returns -1 if a primitive region regionName is already defined or memory couldn’t be
allocated, or 0 if successfully created.
cfxImportAddCompRegComponents
int cfxImportAddCompRegComponents(componentCount,components)
int componentCount;
char **components;

Mesh Import API
Contents Index Help
Add a set of component region names specified in components to the composite region
currently being defined. componentCount specified how many components are specified
in the components array,
Returns -1 if a composite region isn’t being defined or insufficient memory is available to
add the components of the composite region, or 0 if the components were successfully
added.
cfxImportEndCompReg
int cfxImportEndCompReg()
Finish defining the current composite region.
Returns -1 if a composite region isn’t currently being defined or 0 otherwise.
cfxImportCompositeRegion
int cfxImportCompositeRegion(regionName, componentCount, components)
char *regionName, **components;
int componentCount;
Define a composite region named regionName with componentCount components
supplied in character array components.
Returns 0 if successful or -1 if an error occurred preventing the composite region being
defined.
Explicit Node Pairing

The following routine provides a method for explicitly marking two nodes as being identical
(or in the same position in space).
cfxImportMap
int cfxImportMap (nodeid, mapid)
int nodeid, mapid;
Explicitly map the node identified by nodeid to the node identified by mapid.
On calling cfxImportDone the Import Mesh API will update regions and elements
referencing the mapped node to the node it is mapped to. This therefore reduces the total
node count imported to CFX-5 and eliminates the duplicate nodes.
Duplicate nodes may also be removed by CFX-5 if the appropriate options are turned on in
the CFX-5 interface and an appropriate tolerance set. See Mesh Import Editor (p. 88 in
CFX-Pre).

Mesh Import API
Contents Index Help
FORTRAN Interface
The following routines are callable from FORTRAN, and interface with the corresponding C
routine. There are currently no return values.
cfxinit
call cfxinit
Interface to cfxImportInit. Initialises for import.
cfxtest
CHARACTER*n filename
call cfxtest(filename)
Interface to cfxImportTest. Filename is a CHARACTER*n value which gives the name
of the file to dump the output to.
cfxdone
call cfxdone
Interface to cfxImportDone. Terminates import and transfers the data.
cfxnode
INTEGER idnode
REAL x,y,z
call cfxnode(idnode,x,y,z)
Interface to cfxImportNode. idnode is an INTEGER value for the node ID, and x, y, and
z are the REAL coordinates of the node.
cfxelem
INTEGER idelem,itelem,nodes(*)
call cfxelem(idelem,itelem,nodes)
Interface to cfxImportElement. idelem is element ID, and itelem is the element type
(number of nodes - 4,5,6, or 8). Both are INTEGERS. Nodes is an array of INTEGER node
ID’s dimensioned of size at least itelem.
cfxregn
CHARACTER*n regname
INTEGER type,nobjs,objs(*)

Mesh Import API
Contents Index Help
call cfxregn(regname,type,nobjs,objs)
Interface to cfxImportRegion. Regname is a CHARACTER*n string defining the region
name, type is an INTEGER value specifying the type of region, either 1 for nodes, 2 for
faces, or 3 for elements. Nobjs is an INTEGER value which gives the number of objects in
the region, and objs is an INTEGER array of object ID’s dimensioned at least size nobjs.
Unsupported routines previously available in the API

In CFX-5.7.1 certain functionality available in previous releases are no longer supported.
These routines have been removed as they are directly implemented in CFX-5.
The following is a list of routines removed from the mesh import API:
cfxImportFixElements
cfxImportTolerance
cfxImportGetTol
cfxImportSetCheck
cfxImportRange
cfxImportCheck
cfxtol
cfxset
cfxchk

Mesh Import API
Contents Index Help
Import Programs
The following documents the currently available import programs and their command line
options. Each of these are available from within the CFX-Pre User Interface and you are
strongly advised to use them by selecting the appropriate mesh type on the Import Mesh
form, rather than running them directly using the User Import option, wherever possible. See
Mesh Import Editor (p. 88 in CFX-Pre) for more details on the Import Mesh form.
If you wish to use command line options which cannot be specified through the CFX-Pre
User Interface, then you may wish to run these programs as user-defined mesh import
programs. See Using your Custom Import Format (p. 68) for details on how to run a mesh
import program. The programs can be found in <CFXROOT>/bin/<os>/, where <CFXROOT>
is the directory in which CFX is installed, and<os> is the architecture of the machine that
you are running on (e.g. one of solaris, irix, hpux, aix, winnt, linux). To find out
what <CFXROOT> is for your installation, see Specific Directory Names (p. 4 in CFX-5
Installation). To find out what <os> is for your machine, see Operating System Names
(p. 5 in CFX-5 Installation).
TASCflow v2
Imports TASCflow Version 2 files. The external import routine is ImportGRD. The import
routine will read the interface information from the GRD file and automatically remove
duplicate nodes, thus the duplicate node checking (options -d and -D) is unneeded.
Available command line options are:
-v Verbose output. Echo additional data to stdout during the import.
-V More verbose output.
-i Ignore the blockoff file (BCF).
-c Ignore GCI file.
-o Old style 2.4 format.
-b <file> Specifies bcf file which contains blocked-off regions (boundary condition
information is ignored. See CFX-TASCflow v2 (p. 91 in CFX-Pre)).
-g <file> Specifies gci file to import. See CFX-TASCflow v2 (p. 91 in CFX-Pre)).
-f Formatted (ASCII) GRD file.
-u FORTRAN unformatted GRD file.
-3 Import labelled 3-D regions.
-M <machine type> Set the machine type in the case of a binary or unformatted file so
that data conversion may be done if needed. The default file format is 32-bit IEEE (Iris, Sun,
HP, IBM). The currently recognised machine types are:
• IEEE - generic 32-bit IEEE machine.
Page 82 Import Programs CFX-5.7.1
Mesh Import API
Contents Index Help
• BSIEEE - generic 32-bit byteswapped IEEE machine.
• IBM - IBM 32-bit IEEE.
• IRIS - Iris 32-bit IEEE.
• HP - HP 32-bit IEEE.
• SUN - Sun 32-bit IEEE.
• ALPHA - Compaq Tru64 UNIX Alpha 64-bit byte-swapped IEEE.
• DOS - DOS 16-bit byte-swapped IEEE.
• Compaq Tru64 UNIX - Compaq Tru64 UNIX 32-bit byte-swapped IEEE.
• CRAY - Cray 64-bit format.
• CONVEX - native Convex floating point format.
• Windows - 32-bit Windows.
The argument machine type is case insensitive, and only the first 2 characters are needed
(any others are ignored).
CFX-5 Def/Res
Imports the mesh from a CFX-5 Definition or Results file. The external import routine is
ImportDef. Available options are:
CFX-TfC
Imports a CFX-TfC 1.3 mesh file. The external import routine is ImportGEM.
Available options are:
-f Input file is formatted.
-u Input file is unformatted (FORTRAN).
-r Read regions from BFI file.
-b <file> Use file as BFI file name instead of default name.

Mesh Import API
Contents Index Help
CFX-4
Imports a CFX-4 grid file. The external import routine is ImportCFX4.
-C Read coordinates as being in cylindrical coordinates.
-i Included interfaces in regions.
-3 Include USER3D and POROUS regions as 3D regions.
-c Import blocked-off conducting solid regions as 3D regions.
-l Include blocked-off solid regions as 3D regions.
-X Import axisymmetric problem with default values in geometry file.
-a <nk> Override the number of planes created in the k direction by nk (e.g. split theta with
nk planes) for axisymmetric import.
-A <theta> Create a total sector of theta degrees for axisymmetric import.
-S Rename multiple symmetry planes with the same name to conform to CFX-5 Solver
requirements (i.e. must lie in a plane).
CFX-5.1
Imports a CFX-5.1 Results File. The external import routine is ImportCFX5.
-f Input file is formatted.
Mesh Import API
Contents Index Help
-u Input file is unformatted (FORTRAN).
PATRAN
Imports a PATRAN Neutral file. The external import routine is ImportPatran. Reads
packet 01 (nodes) as nodes, packet 02 (elements) as elements, and nodes (type 5) from
packet 21 (named groups) as regions. A command line option is available to read packet 06
(loads) as regions also. All other packets are read, but not processed.
-l Import packet 06 (distributed loads) as regions. The regions will be assigned the name
PatranLoadX where the X is replaced by the load ID number.
I-DEAS
Imports an I-DEAS Universal file from SDRC. The external import routine is ImportIDEAS.
Reads datasets 781 and 2411 (nodes) as nodes, 780 and 2412 (elements) as elements,
and nodes (type 7) from datasets 752 and 2417 (permanent groups) as regions. All other
datasets are read, but not processed.
Mesh Import API
Contents Index Help
-n Import nodes in a PERMANENT group as a 2D region.
-l Import elements in a PERMANENT group as a 3D region.
-f Import faces in a PERMANENT group as a 2D region.
GridPro/az3000
Imports a GridPro/az3000 grid and connectivity file from Program Development Corporation
(PDC).
The external import routine is ImportPDC. The import routine will attempt to determine the
connectivity file associated with the grid file by appending the extension conn to the grid file
name. If the file is not found, then the grid file name extension will be replaced by conn and
the new file checked for. If neither of these are found, the import routine will look for a file
named conn.tmp, and if found will use it. A command line option (-c) is also available to
explicitly name the connectivity file.
If a connectivity file is found, the interface information in the file will be used to eliminate the
duplicate nodes at block interfaces, and boundaries conditions will be imported as regions
into CFX-5. If the boundary condition is named in the connectivity file, then that name will
be used for the region name, else the default name UnnamedRegionX with the X replaced
by a number will be used. If a connectivity file is not found, or the command line option to
ignore the connectivity file is given (-i), then only the grid file will be imported, resulting in
duplicate nodes at the block interfaces. You may then wish to eliminate these duplicate
nodes with the command line option (-d or -D).
-i Ignore the connectivity file. Duplicate nodes will result and no regions will be imported.
-c <connfile> Set the name of the connectivity file associated with the grid file to
connfile.
-p Include periodic boundary conditions as regions. These are not normally included in the
import. Setting this flag will result in these being imported as regions.
-q Read from the property file
-P <propfile> Set the name of the property file associated with the grid file to
propfile.
-3 Import grid blocks as 3-D regions
NASTRAN
Imports a NASTRAN file. The external import routine is ImportMSC. Currently reads only
nodes (GRID), tet (CTETRA) and hex (CHEXA) elements.
Mesh Import API
Contents Index Help
-l Import PLOAD4 datasets as 2D regions.
-s Import 3D regions.
ICEM CFX
Imports a file written for CFX-5 by ICEM Tetra. The external import routine is ImportICEM.
-P Read coordinate data from a binary file as double precision.
ANSYS
Imports an ANSYS file The external import routine is ImportANSYS. Available options are:
-l Process packet 6 (distributed loads).
CGNS
Imports a CGNS file The external import routine is ImportCGNS. Available options are:
-b Read a grid from the specific CGNS base.
-B Read all CGNS bases. (default)
-c Read BOCO information as 2D regions.
SplitCGNS.exe
The SplitCGNS.exe program will take a single CGNS file and split it into multiple files on
a "file per problem basis". The method for running this is:
SplitCGNS.exe [ -l ] <filename> <basename>
If the file contains two problems called "Pipe" and "Elbow", the import filter will only currently
read "Pipe", but using SplitCGNS will produce two files called basename_Pipe.cgns and
basename_Elbow.cgns each containing a single problem which can then be selected for
import via the normal method.
Specifying the "-l" option "links" the part of the data in the original file to the created file
using a relative pathname. The created file does not therefore need to duplicate data.

Mesh Import API
Contents Index Help
The "-l" option should only be used if the original file and resulting files are going to be kept
relative to each other i.e. if when SplitCGNS was run the original file was in ../../
example.cgns, it must always remain in this position relative to the created files.

Mesh Import API

Caricato da

Informazioni sul documento

Descrizione originale:

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Mesh Import API

Caricato da

Copyright:

Formati disponibili

CFX-5 Reference Guide

Master Master Help On

Import Mesh API

• Introduction to the Import Mesh API p. 58

• Creating your own Mesh Import Program p. 59

• Using your Custom Import Format p. 68

Introduction to the Import Mesh API

Valid Mesh Elements in CFX-5

Prismatic (Wedge) Hexahedral

Page 58 Introduction to the Import Mesh API CFX-5.7.1

Creating your own Mesh Import Program

A Custom Mesh Import Example

Page 59 Creating your own Mesh Import Program CFX-5.7.1

static char options[] = "velF:";

static char *usgmsg[] = {

void main (argc, argv)

Page 60 Creating your own Mesh Import Program CFX-5.7.1

while ((n = getargs (argc, argv, options)) > 0) {

while (packet != 99) { Loop through all the packets

Page 61 Creating your own Mesh Import Program CFX-5.7.1

Page 62 Creating your own Mesh Import Program CFX-5.7.1

else if (packet == 6 && do_loads) {

/* add if element load flag is set */

Page 63 Creating your own Mesh Import Program CFX-5.7.1

/* print summary */ Print a summary of the import

Page 64 Creating your own Mesh Import Program CFX-5.7.1

Linking your Code into CFX-5

Page 66 Linking your Code into CFX-5 CFX-5.7.1

Page 67 Linking your Code into CFX-5 CFX-5.7.1

Using your Custom Import Format

Running the program from CFX-Pre

Page 68 Using your Custom Import Format CFX-5.7.1

Page 69 API Functions CFX-5.7.1

Node regions are specified by a list of node ID’s.

Page 70 API Functions CFX-5.7.1

Page 71 API Functions CFX-5.7.1

Error Handling Routines

Page 72 API Functions CFX-5.7.1

Page 73 API Functions CFX-5.7.1

Page 74 API Functions CFX-5.7.1

Page 75 API Functions CFX-5.7.1

Primitive Region Routines

Page 76 API Functions CFX-5.7.1

Composite Regions Routines

Page 78 API Functions CFX-5.7.1

Explicit Node Pairing

Page 79 API Functions CFX-5.7.1

Page 80 API Functions CFX-5.7.1

Unsupported routines previously available in the API

Page 81 API Functions CFX-5.7.1

Page 83 Import Programs CFX-5.7.1

Page 87 Import Programs CFX-5.7.1

Page 88 Import Programs CFX-5.7.1

Potrebbero piacerti anche