apiGridModel.h

Go to the documentation of this file.

#ifndef _APIGRIDMODEL_H_
#define _APIGRIDMODEL_H_
/****************************************************************************
 *
 * Pointwise PWGM API (PWGM-API) v1.0
 *
 * (C) 2021 Cadence Design Systems, Inc. All rights reserved worldwide.
 *
 ***************************************************************************/
 
// See comments in core code for information on adding new PWGM API functions.
 
#include <stdio.h>
 
#include "apiPWP.h"
 
#if defined(WINDOWS) && defined(SHOW_PWGM_MESSAGES)
#    if !defined(PWGM_HIDE_EXPORT_API)
 
#        define PWGM_HIDE_IMPORT_API
#    if !defined(PWGM_HIDE_UNSTRUCTURED_API) && defined(PWGM_HIDE_STRUCTURED_API)
#            pragma message ("FYI: Using Unstructured Export PWGM API")
#        elif defined(PWGM_HIDE_UNSTRUCTURED_API) && !defined(PWGM_HIDE_STRUCTURED_API)
#            pragma message ("FYI: Using Structured Export PWGM API")
#        elif !defined(PWGM_HIDE_UNSTRUCTURED_API) && !defined(PWGM_HIDE_STRUCTURED_API)
#            pragma message ("WARNING: Using Hybrid Export PWGM API")
#        else //defined(PWGM_HIDE_UNSTRUCTURED_API) && defined(PWGM_HIDE_STRUCTURED_API)
#            error ("ERROR: Export PWGM API is INVISIBLE!")
#    endif
 
#    else // !defined(PWGM_HIDE_EXPORT_API)
 
#        pragma message ("FYI: Using Import PWGM API")
 
#    endif // !defined(PWGM_HIDE_EXPORT_API)
#endif // WINDOWS && SHOW_PWP_MESSAGES
 
 
#undef PW_DLL_IMPEXP
#ifdef BUILD_GGPLUGIN
# define PW_DLL_IMPEXP PW_DLLEXPORT
#else
# define PW_DLL_IMPEXP PW_DLLIMPORT
#endif
 // sdkINTERNALS
 
/*
 
The Pointwise CAE Plugin API
    Using C++
        CAE Plugin Classes
        Grid Model Classes
    Using C
        Progress Handling
        CAE Plugin File Handling
        CAE Value to Text Functions
        CAEP Message Handling
        CAEP Variable Manager Tools
        CAEP Macros
        GRDP Message Handling
        GRDP Variable Manager Tools
        GRDP Macros
        Pointwise Grid Model API Specification (PWGM-API)
        Platform Endian Handling
        Unformatted FORTRAN File Handling
Pointwise Grid Import Plugin API
    Using C++
        GRDP Plugin Classes
        Grid Model Classes
    Using C
The Pointwise Grid Model API
    Using C++
    Using C
Miscellaneous Data Types and Classes
The Low Level Plugin API Functions
    Pointwise CAE Plugin API Specification (CAEP-API)
    Pointwise Grid Import Plugin API Specification (GRDP-API)
    Pointwise Plugin API Specification (PWP-API)
 
*/
 
extern "C" {
 
/***********************************************************/
/***********************************************************/
/***********************************************************/
/***********************************************************/ // end DOXGRP_APIPWGM_IMPORT
 
 // DOXGRP_APIPWGM_IMPORT_UNS
 
 // DOXGRP_APIPWGM_IMPORT_STR
 
 
 
/***********************************************************/
/***********************************************************/
PWP_DECLARE_HANDLE(PWGM_HGRIDMODEL);
#define PWGM_HGRIDMODEL_ISVALID(h) PWP_HANDLE_ISVALID(h)
 
#define PWGM_HGRIDMODEL_INIT       PWP_HANDLE_INIT
 
#define PWGM_HGRIDMODEL_SET(h, v)  PWP_HANDLE_SET(h, v)
 
#define PWGM_HGRIDMODEL_SET_INVALID(h)  PWGM_HGRIDMODEL_SET(h, PWP_HANDLE_INIT)
 
#define PWGM_HGRIDMODEL_OUT_GMIMPL(h) ((PWGM_HGRIDMODEL_OUT_IMPL*)h)
 
#define PWGM_HGRIDMODEL_IN_GMIMPL(h) ((PWGM_HGRIDMODEL_IN_IMPL*)h)
 // sdkINTERNALS
 
PWP_DECLARE_HELEMGROUP(PWGM_HGRIDMODEL, PWGM_HBLOCK);
 
#define PWGM_HBLOCK_ISVALID(h)    PWP_HEGRP_ISVALID(h)
 
#define PWGM_HBLOCK_INIT          PWP_HEGRP_INIT
 
#define PWGM_HBLOCK_SET(h, p, v)  PWP_HEGRP_SET(h, p, v)
 
#define PWGM_HBLOCK_SET_INVALID(h)  PWGM_HBLOCK_SET(h, 0, PWP_BADID)
 
#define PWGM_HBLOCK_OUT_GMIMPL(h) ((PWGM_HGRIDMODEL_OUT_IMPL*)PWP_HEGRP_H(h))
 
#define PWGM_HBLOCK_IN_GMIMPL(h) ((PWGM_HGRIDMODEL_IN_IMPL*)PWP_HEGRP_H(h))
 // sdkINTERNALS
 
#define PWGM_HBLOCK_H(h)          PWP_HEGRP_H(h) 
 
#define PWGM_HBLOCK_ID(h)         PWP_HEGRP_ID(h)
 
#define PWGM_HBLOCK_MODEL(h)      PWP_HEGRP_H(h) 
 
PWP_DECLARE_HELEMGROUP(PWGM_HGRIDMODEL, PWGM_HDOMAIN);
#define PWGM_HDOMAIN_ISVALID(h)    PWP_HEGRP_ISVALID(h)
 
#define PWGM_HDOMAIN_INIT          PWP_HEGRP_INIT
 
#define PWGM_HDOMAIN_SET(h, p, v)  PWP_HEGRP_SET(h, p, v)
 
#define PWGM_HDOMAIN_SET_INVALID(h)  PWGM_HDOMAIN_SET(h, 0, PWP_BADID)
 
#define PWGM_HDOMAIN_OUT_GMIMPL(h) ((PWGM_HGRIDMODEL_OUT_IMPL*)PWP_HEGRP_H(h))
 
#define PWGM_HDOMAIN_IN_GMIMPL(h) ((PWGM_HGRIDMODEL_IN_IMPL*)PWP_HEGRP_H(h))
 // sdkINTERNALS
 
#define PWGM_HDOMAIN_H(h)          PWP_HEGRP_H(h) 
 
#define PWGM_HDOMAIN_ID(h)         PWP_HEGRP_ID(h)
 
#define PWGM_HDOMAIN_MODEL(h)      PWP_HEGRP_H(h) 
 
PWP_DECLARE_HELEMGROUP(PWGM_HGRIDMODEL, PWGM_HVERTEX);
#define PWGM_HVERTEX_ISVALID(h)    PWP_HEGRP_ISVALID(h)
 
#define PWGM_HVERTEX_INIT          PWP_HEGRP_INIT
 
#define PWGM_HVERTEX_SET(h, p, v)  PWP_HEGRP_SET(h, p, v)
 
#define PWGM_HVERTEX_SET_INVALID(h)  PWGM_HVERTEX_SET(h, 0, PWP_BADID)
 
#define PWGM_HVERTEX_OUT_GMIMPL(h) ((PWGM_HGRIDMODEL_OUT_IMPL*)PWP_HEGRP_H(h))
 // sdkINTERNALS
 
#define PWGM_HVERTEX_H(h)          PWP_HEGRP_H(h) 
 
#define PWGM_HVERTEX_ID(h)         PWP_HEGRP_ID(h)
 
#define PWGM_HVERTEX_MODEL(h)      PWP_HEGRP_H(h) 
 
 
PWP_DECLARE_HELEMGROUP(PWGM_HGRIDMODEL, PWGM_HELEMENT_BASE);
 
 
PWP_DECLARE_HEGRPITEM(PWGM_HELEMENT_BASE, PWGM_HELEMENT);
#define PWGM_HELEMENT_ISVALID(h)        PWP_HEGI_ISVALID(h)
 
#define PWGM_HELEMENT_INIT              PWP_HEGI_INIT
 
#define PWGM_HELEMENT_SET(h,p,tt,sv,v)  PWP_HEGI_SET(h,p,tt,sv,v)
 
#define PWGM_HELEMENT_SET_INVALID(h)  PWGM_HELEMENT_SET(h, 0, PWP_BADTYPE, \
                                            PWP_BADID, PWP_BADID)
 
#define PWGM_HELEMENT_OUT_GMIMPL(h) ((PWGM_HGRIDMODEL_OUT_IMPL*)PWGM_HELEMENT_MODEL(h))
 // sdkINTERNALS
 
#define PWGM_HELEMENT_H(h)              PWP_HEGI_H(h)
 
#define PWGM_HELEMENT_PID(h)            PWP_HEGI_PID(h)
 
#define PWGM_HELEMENT_PTYPE(h)          PWP_HEGI_PTYPE(h)
 
#define PWGM_HELEMENT_ID(h)             PWP_HEGI_ID(h)
 
#define PWGM_HELEMENT_MODEL(h)          PWP_HEGI_H(h)
 
 
PWP_DECLARE_HELEMGROUP(PWGM_HGRIDMODEL, PWGM_HBNDRY);
#define PWGM_HBNDRY_ISVALID(h)    PWP_HEGRP_ISVALID(h)
 
#   define PWGM_HBNDRY_INIT          PWP_HEGRP_INIT
 
#   define PWGM_HBNDRY_SET(h, p, v)  PWP_HEGRP_SET(h, p, v)
 
#   define PWGM_HBNDRY_SET_INVALID(h)  PWGM_HBNDRY_SET(h, 0, PWP_BADID)
 
#define PWGM_HBNDRY_OUT_GMIMPL(h) ((PWGM_HGRIDMODEL_OUT_IMPL*)PWP_HEGRP_H(h))
 // sdkINTERNALS
 
#define PWGM_HBNDRY_H(h)          PWP_HEGRP_H(h) 
 
#define PWGM_HBNDRY_ID(h)         PWP_HEGRP_ID(h)
 
#define PWGM_HBNDRY_MODEL(h)      PWP_HEGRP_H(h) 
 
 
PWP_DECLARE_HELEMGROUP(PWGM_HGRIDMODEL, PWGM_HCNXN);
#define PWGM_HCNXN_ISVALID(h)    PWP_HEGRP_ISVALID(h)
 
#   define PWGM_HCNXN_INIT          PWP_HEGRP_INIT
 
#   define PWGM_HCNXN_SET(h, p, v)  PWP_HEGRP_SET(h, p, v)
 
#   define PWGM_HCNXN_SET_INVALID(h)  PWGM_HCNXN_SET(h, 0, PWP_BADID)
 
#define PWGM_HCNXN_OUT_GMIMPL(h) ((PWGM_HGRIDMODEL_OUT_IMPL*)PWP_HEGRP_H(h))
 // sdkINTERNALS
 
#define PWGM_HCNXN_H(h)          PWP_HEGRP_H(h) 
 
#define PWGM_HCNXN_ID(h)         PWP_HEGRP_ID(h)
 
#define PWGM_HCNXN_MODEL(h)      PWP_HEGRP_H(h) 
 
 
//---------------------------------------------------------------------------
PWP_DECLARE_HELEMGROUP(PWGM_HGRIDMODEL, PWGM_HCONNECTOR);
#define PWGM_HCONNECTOR_ISVALID(h)    PWP_HEGRP_ISVALID(h)
 
#define PWGM_HCONNECTOR_INIT          PWP_HEGRP_INIT
#define PWGM_HCONNECTOR_SET(h, p, v)  PWP_HEGRP_SET(h, p, v)
#define PWGM_HCONNECTOR_SET_INVALID(h)  PWGM_HCONNECTOR_SET(h, 0, PWP_BADID)
#define PWGM_HCONNECTOR_IN_GMIMPL(h) ((PWGM_HGRIDMODEL_IN_IMPL*)PWP_HEGRP_H(h))
 
#define PWGM_HCONNECTOR_H(h)          PWP_HEGRP_H(h) 
#define PWGM_HCONNECTOR_ID(h)         PWP_HEGRP_ID(h)
#define PWGM_HCONNECTOR_MODEL(h)      PWP_HEGRP_H(h) 
 
 
//---------------------------------------------------------------------------
PWP_DECLARE_HELEMGROUP(PWGM_HGRIDMODEL, PWGM_HVERTEXLIST_BASE);
 
PWP_DECLARE_HEGRPITEM(PWGM_HVERTEXLIST_BASE, PWGM_HVERTEXLIST);
#define PWGM_HVERTEXLIST_ISVALID(h)        PWP_HEGI_ISVALID(h)
 
#define PWGM_HVERTEXLIST_INIT              PWP_HEGI_INIT
 
#define PWGM_HVERTEXLIST_SET(h,p,tt,sv,v)  PWP_HEGI_SET(h,p,tt,sv,v)
 
#define PWGM_HVERTEXLIST_SET_INVALID(h)  PWGM_HVERTEXLIST_SET(h, 0, \
                                            PWP_BADTYPE, PWP_BADID, PWP_BADID)
 
#define PWGM_HVERTEXLIST_IN_GMIMPL(h) ((PWGM_HGRIDMODEL_IN_IMPL*)PWGM_HVERTEXLIST_MODEL(h))
 // sdkINTERNALS
 
#define PWGM_HVERTEXLIST_H(h)              PWP_HEGI_H(h)
 
#define PWGM_HVERTEXLIST_PID(h)            PWP_HEGI_PID(h)
 
#define PWGM_HVERTEXLIST_PTYPE(h)          PWP_HEGI_PTYPE(h)
 
#define PWGM_HVERTEXLIST_ID(h)             PWP_HEGI_ID(h)
 
#define PWGM_HVERTEXLIST_MODEL(h)          PWP_HEGI_H(h)
 
 
//---------------------------------------------------------------------------
PWP_DECLARE_HELEMGROUP(PWGM_HGRIDMODEL, PWGM_HBLOCKASSEMBLER);
#define PWGM_HBLOCKASSEMBLER_ISVALID(h)    PWP_HEGRP_ISVALID(h)
 
#define PWGM_HBLOCKASSEMBLER_INIT          PWP_HEGRP_INIT
#define PWGM_HBLOCKASSEMBLER_SET(h, p, v)  PWP_HEGRP_SET(h, p, v)
#define PWGM_HBLOCKASSEMBLER_SET_INVALID(h)  PWGM_HBLOCKASSEMBLER_SET(h, 0, PWP_BADID)
#define PWGM_HBLOCKASSEMBLER_IN_GMIMPL(h) ((PWGM_HGRIDMODEL_IN_IMPL*)PWP_HEGRP_H(h))
 
#define PWGM_HBLOCKASSEMBLER_H(h)          PWP_HEGRP_H(h) 
#define PWGM_HBLOCKASSEMBLER_ID(h)         PWP_HEGRP_ID(h)
#define PWGM_HBLOCKASSEMBLER_MODEL(h)      PWP_HEGRP_H(h) 
 
/*---------------------------------------------------------*/
/*       UNSTRUCTURED AND STRUCTURED GRID DATATYPES        */
/*---------------------------------------------------------*/
 
 
typedef PWP_REAL PWGM_XYZVAL;
 
 
struct PW_DLL_IMPEXP PWGM_VERTDATA {
    PWGM_XYZVAL x; 
    PWGM_XYZVAL y; 
    PWGM_XYZVAL z; 
    PWP_UINT32  i; 
};
 
 
/*---------------------------------------------------------*/
enum PWGM_XYZ_CLUSTERING {
    PWGM_CLUSTERING_XYXY,     
    PWGM_CLUSTERING_XXYY,     
    PWGM_CLUSTERING_XYZXYZ,   
    PWGM_CLUSTERING_XXYYZZ,   
 
    PWGM_CLUSTERING_SIZE,
    PWGM_CLUSTERING_LAST = PWGM_CLUSTERING_SIZE - 1
 // sdkINTERNALS
};
 
 
struct PW_DLL_IMPEXP PWGM_CONDDATA {
    const char *    name;  
    PWP_UINT32      id;     
    const char *    type;  
    PWP_UINT32      tid;    
};
 
#define PWGM_UNSPECIFIED_COND_ID    PWP_UINT32(2147483647)
 
#define PWGM_UNSPECIFIED_TYPE_ID    PWP_UINT32(0)
 
 
/*---------------------------------------------------------*/
/*             UNSTRUCTURED GRID DATATYPES                 */
/*---------------------------------------------------------*/
 
enum PWGM_ENUM_ELEMTYPE {
    PWGM_ELEMTYPE_BAR,     
    PWGM_ELEMTYPE_HEX,     
    PWGM_ELEMTYPE_QUAD,    
    PWGM_ELEMTYPE_TRI,     
    PWGM_ELEMTYPE_TET,     
    PWGM_ELEMTYPE_WEDGE,   
    PWGM_ELEMTYPE_PYRAMID, 
    PWGM_ELEMTYPE_POINT,   
    PWGM_ELEMTYPE_POLYH,   
    PWGM_ELEMTYPE_POLYG,   
    /* add new enum values before this line */
 
    PWGM_ELEMTYPE_SIZE,
    PWGM_ELEMTYPE_LAST = PWGM_ELEMTYPE_SIZE-1
 // sdkINTERNALS
};
 
 
enum PWGM_ENUM_ELEMORDER {
    PWGM_ELEMORDER_HEX = PWGM_ELEMTYPE_HEX,
    PWGM_ELEMORDER_QUAD = PWGM_ELEMTYPE_QUAD,
    PWGM_ELEMORDER_TRI = PWGM_ELEMTYPE_TRI,
    PWGM_ELEMORDER_TET = PWGM_ELEMTYPE_TET,
    PWGM_ELEMORDER_WEDGE = PWGM_ELEMTYPE_WEDGE,
    PWGM_ELEMORDER_PYRAMID = PWGM_ELEMTYPE_PYRAMID,
    PWGM_ELEMORDER_VC,
    /* add new enum values before this line */
 
    PWGM_ELEMORDER_SIZE,
    PWGM_ELEMORDER_LAST = PWGM_ELEMORDER_SIZE-1
 // sdkINTERNALS
};
 
 
#define PWGM_ELEMDATA_VERT_SIZE  8
 
 
struct PW_DLL_IMPEXP PWGM_ELEMDATA {
    PWGM_ENUM_ELEMTYPE type;                            
    PWP_UINT32         vertCnt;                         
    PWGM_HVERTEX       vert[PWGM_ELEMDATA_VERT_SIZE];   
    PWP_UINT32         index[PWGM_ELEMDATA_VERT_SIZE];  
};
 
 
struct PW_DLL_IMPEXP PWGM_ENUMELEMDATA {
    PWGM_ELEMDATA elemData;     
    PWGM_HELEMENT hBlkElement;  
};
 
 
struct PW_DLL_IMPEXP PWGM_POLYELEMDATA {
    PWGM_ENUM_ELEMTYPE  type;
    PWP_UINT64          vertCnt;
    const PWP_UINT64 *  indices;
    PWP_UINT64          numFaces;
    const PWP_UINT64 *  offsets;
    PWP_UINT64          numFaceIndices;
    const PWP_UINT64 *  faceIndices;
};
 
 
struct PW_DLL_IMPEXP PWGM_ELEMCOUNTS {
    PWP_UINT32 count[PWGM_ELEMTYPE_SIZE];
};
 
#define PWGM_ECNT_Point(ecs)   (ecs).count[PWGM_ELEMTYPE_POINT]
 
#define PWGM_ECNT_Bar(ecs)     (ecs).count[PWGM_ELEMTYPE_BAR]
 
#define PWGM_ECNT_Hex(ecs)     (ecs).count[PWGM_ELEMTYPE_HEX]
 
#define PWGM_ECNT_Quad(ecs)    (ecs).count[PWGM_ELEMTYPE_QUAD]
 
#define PWGM_ECNT_Tri(ecs)     (ecs).count[PWGM_ELEMTYPE_TRI]
 
#define PWGM_ECNT_Tet(ecs)     (ecs).count[PWGM_ELEMTYPE_TET]
 
#define PWGM_ECNT_Wedge(ecs)   (ecs).count[PWGM_ELEMTYPE_WEDGE]
 
#define PWGM_ECNT_Pyramid(ecs) (ecs).count[PWGM_ELEMTYPE_PYRAMID]
 
#define PWGM_ECNT_Polyhedron(ecs) (ecs).count[PWGM_ELEMTYPE_POLYH]
 
#define PWGM_ECNT_Polygon(ecs) (ecs).count[PWGM_ELEMTYPE_POLYG]
 
 
 
enum PWGM_ENUM_XYZ {
    PWGM_XYZ_X, 
    PWGM_XYZ_Y, 
    PWGM_XYZ_Z, 
    // add new enum values before this line
 
    PWGM_XYZ_SIZE,
    PWGM_XYZ_LAST = PWGM_XYZ_SIZE-1
 // sdkINTERNALS
};
 
 
 
/*---------------------------------------------------------*/
/*               STRUCTURED GRID DATATYPES                 */
/*---------------------------------------------------------*/
 
enum PWGM_ENUM_GRIDTYPE {
    PWGM_GRIDTYPE_STRUCTURED,   
    PWGM_GRIDTYPE_UNSTRUCTURED, 
 
    PWGM_GRIDTYPE_SIZE,
    PWGM_GRIDTYPE_LAST = PWGM_GRIDTYPE_SIZE-1
 // sdkINTERNALS
};
 
 
struct PW_DLL_IMPEXP PWGM_INDEX3 {
    PWP_INT32 i; 
    PWP_INT32 j; 
    PWP_INT32 k; 
};
 
/*---------------------------------------------------------*/
struct PW_DLL_IMPEXP PWGM_INDEX2 {
    PWP_INT32 i; 
    PWP_INT32 j; 
};
 
typedef PWGM_INDEX3 PW_DLL_IMPEXP PWGM_STR_SIZE;
 
 
struct PW_DLL_IMPEXP PWGM_STR_RANGE {
    PWGM_INDEX3 beg; 
    PWGM_INDEX3 end; 
};
 
 
struct PW_DLL_IMPEXP PWGM_INDEX_XFORM {
    PWP_INT32 m[3][4]; 
};
 
 
struct PW_DLL_IMPEXP PWGM_INDEX_XFORM2 {
    PWP_INT32 m[2][3]; 
};
 
 
enum PWGM_FACE_ID {
    PWGM_FACE_KMIN,  
    PWGM_FACE_KMAX,  
    PWGM_FACE_IMIN,  
    PWGM_FACE_IMAX,  
    PWGM_FACE_JMIN,  
    PWGM_FACE_JMAX,  
    PWGM_FACE_UNSTR, 
    // add new enum values before this line
 
    PWGM_FACE_SIZE,
    PWGM_FACE_LAST = PWGM_FACE_SIZE-1
 // sdkINTERNALS
};
 
 
enum PWGM_CNXNTYPE {
    PWGM_CNXNTYPE_ONE_TO_ONE,   
    PWGM_CNXNTYPE_MANY_TO_ONE,  
    PWGM_CNXNTYPE_MANY_TO_MANY, 
    PWGM_CNXNTYPE_NONE,         
    // add new enum values before this line
 
    PWGM_CNXNTYPE_SIZE,
    PWGM_CNXNTYPE_LAST = PWGM_FACE_SIZE-1
 // sdkINTERNALS
};
 
 
struct PW_DLL_IMPEXP PWGM_BNDRYDATA {
    const char     *name; 
    PWGM_HBLOCK    block; 
    PWGM_FACE_ID   face;  
    PWGM_STR_RANGE range; 
};
 
 
struct PW_DLL_IMPEXP PWGM_CNXNDATA {
    const char       *name;    
    PWGM_HBLOCK      block1;   
    PWGM_FACE_ID     face1;    
    PWGM_STR_RANGE   range1;   
    PWGM_INDEX_XFORM from1to2; 
    PWGM_HBLOCK      block2;   
    PWGM_FACE_ID     face2;    
    PWGM_STR_RANGE   range2;   
    PWGM_INDEX_XFORM from2to1; 
};
 
 
struct PW_DLL_IMPEXP PWGM_BLOCKDATA {
    const char         *name;    
    PWGM_HBLOCK        block;    
    PWGM_ENUM_GRIDTYPE gridType; 
    PWGM_STR_SIZE      size;     
};
 
 
enum PWGM_ENUM_IJK {
    PWGM_IJK_I, 
    PWGM_IJK_J, 
    PWGM_IJK_K, 
    // add new enum values before this line
 
    PWGM_IJK_SIZE,
    PWGM_IJK_LAST = PWGM_IJK_SIZE-1
 // sdkINTERNALS
};
 
 
enum PWGM_ENUM_FACETYPE {
    PWGM_FACETYPE_BOUNDARY,
 
    PWGM_FACETYPE_INTERIOR,
 
    PWGM_FACETYPE_CONNECTION,
    // add new enum values before this line
 
    PWGM_FACETYPE_SIZE,
    PWGM_FACETYPE_LAST = PWGM_FACETYPE_SIZE-1
 // sdkINTERNALS
};
 
 
enum PWGM_ENUM_FACEORDER {
    PWGM_FACEORDER_DONTCARE,      
    PWGM_FACEORDER_BOUNDARYFIRST, 
    PWGM_FACEORDER_INTERIORFIRST, 
    PWGM_FACEORDER_BOUNDARYONLY,  
    PWGM_FACEORDER_INTERIORONLY,  
    PWGM_FACEORDER_BCGROUPSFIRST, 
    PWGM_FACEORDER_BCGROUPSLAST,  
    PWGM_FACEORDER_BCGROUPSONLY,  
    PWGM_FACEORDER_VCGROUPSBCLAST,
    PWGM_FACEORDER_BCGROUPSONLY_BYVC,  
    // add new enum values before this line
 
    PWGM_FACEORDER_SIZE,
    PWGM_FACEORDER_LAST = PWGM_FACEORDER_SIZE-1
 // sdkINTERNALS
};
 
 
struct PW_DLL_IMPEXP PWGM_BEGINSTREAM_DATA {
    PWGM_ENUM_FACEORDER order;            
    PWP_UINT32          totalNumFaces;    
    PWP_UINT32          numBoundaryFaces; 
    PWP_UINT32          numInteriorFaces; 
    PWGM_ELEMCOUNTS     counts;           
    PWGM_HGRIDMODEL     model;            
    void *              userData;         
};
 
 
typedef PWP_UINT32 (*PWGM_BEGINSTREAMCB)(PWGM_BEGINSTREAM_DATA *data);
 
 
struct PW_DLL_IMPEXP PWGM_FACEREF_DATA {
    PWP_UINT32 cellIndex;
 
    PWP_UINT32 cellFaceIndex;
 
    //PWP_UINT32 blockFace;  TODO make this work
 
    PWGM_HBLOCK block;
 
    PWGM_HELEMENT blockElem;
 
    PWGM_HDOMAIN domain;
 
    PWGM_HELEMENT domainElem;
};
 
 
struct PW_DLL_IMPEXP PWGM_FACESTREAM_DATA {
    PWGM_HGRIDMODEL model;
 
    PWP_UINT32 face;
 
    PWP_UINT32 neighborCellIndex;
 
    PWGM_ELEMDATA elemData;
 
    PWGM_ENUM_FACETYPE type;
 
    PWGM_FACEREF_DATA owner;
 
    void *userData;
};
 
 
typedef PWP_UINT32 (*PWGM_FACESTREAMCB)(PWGM_FACESTREAM_DATA *data);
 
 
struct PW_DLL_IMPEXP PWGM_ENDSTREAM_DATA {
    PWGM_HGRIDMODEL model;  
    PWP_BOOL ok;            
    void *userData;         
};
 
 
typedef PWP_UINT32 (*PWGM_ENDSTREAMCB)(PWGM_ENDSTREAM_DATA *data);
 
typedef PWP_UINT32          PWGM_CONDKEY;
 
#define PWGM_CONDKEY_UNDEF  PWP_UINT32_UNDEF
 
 
/*---------------------------------------------------------*/
struct PW_DLL_IMPEXP PWGM_ASSEMBLER_DATA {
    PWGM_ENUM_FACETYPE  type;       
    PWP_UINT32          vertCnt;    
    PWP_UINT32          index[4];   
    PWP_UINT32          owner;      
    PWP_UINT32          neighbor;   
};
 
 
typedef PWP_UINT64(*PWGM_INDEXMAPPERCB)(const PWP_UINT64 pwgmNdx, void *data);
 
 
typedef PWGM_INDEX3(*PWGM_INDEX3MAPPERCB)(const PWGM_INDEX3 pwgmNdx, void *data);
 
//*********************************************
//   PWGM-API functions
//*********************************************
 
/***********************************************************/
/***********************************************************/
PW_DLLEXPORT PWP_UINT32
PwModBlockCount(PWGM_HGRIDMODEL model);
 
 
PW_DLLEXPORT PWGM_HBLOCK
PwModEnumBlocks(PWGM_HGRIDMODEL model, PWP_UINT32 ndx);
 
 
PW_DLLEXPORT PWP_BOOL
PwBlkCondition(PWGM_HBLOCK block, PWGM_CONDDATA *pCondData);
 
 
PW_DLLEXPORT inline PWP_BOOL
PwModNdxBlkCondition(const PWGM_HGRIDMODEL model, const PWP_UINT32 ndx,
    PWGM_CONDDATA* pCondData)
{
    return PwBlkCondition(PwModEnumBlocks(model, ndx), pCondData);
}
 
 
PW_DLLEXPORT PWP_BOOL
PwBlock(PWGM_HBLOCK block, PWGM_BLOCKDATA *pBlockData);
 
 
PW_DLLEXPORT PWP_BOOL
PwBlkSetExportName(PWGM_HBLOCK block, const char *name);
 
 
PW_DLLEXPORT PWP_BOOL
PwModGetAttributeValue(PWGM_HGRIDMODEL model, const char *name,
    PWP_ENUM_VALTYPE bufType, void *buf, PWP_UINT count);
 
 
PWP_BOOL
PwModGetAttributeString(PWGM_HGRIDMODEL model, const char *name, const char ** val);
 
PWP_BOOL
PwModGetAttributeUINT(PWGM_HGRIDMODEL model, const char *name, PWP_UINT *val);
 
PWP_BOOL
PwModGetAttributeUINT32(PWGM_HGRIDMODEL model, const char *name, PWP_UINT32 *val);
 
PWP_BOOL
PwModGetAttributeINT(PWGM_HGRIDMODEL model, const char *name, PWP_INT *val);
 
PWP_BOOL
PwModGetAttributeINT32(PWGM_HGRIDMODEL model, const char *name, PWP_INT32 *val);
 
PWP_BOOL
PwModGetAttributeREAL(PWGM_HGRIDMODEL model, const char *name, PWP_REAL *val);
 
PWP_BOOL
PwModGetAttributeFLOAT(PWGM_HGRIDMODEL model, const char *name, PWP_FLOAT *val);
 
PWP_BOOL
PwModGetAttributeBOOL(PWGM_HGRIDMODEL model, const char *name, PWP_BOOL *val);
 
PWP_BOOL
PwModGetAttributeEnum(PWGM_HGRIDMODEL model, const char *name, const char ** val);
 
/***********************************************************/
#if !defined(PWGM_HIDE_UNSTRUCTURED_API) && !defined(PWGM_HIDE_EXPORT_API)
 
PW_DLLEXPORT PWP_UINT32
PwModDomainCount(PWGM_HGRIDMODEL model);
 
 
PW_DLLEXPORT PWGM_HDOMAIN
PwModEnumDomains(PWGM_HGRIDMODEL model, PWP_UINT32 ndx);
 
 
PW_DLLEXPORT PWGM_HVERTEX
PwModEnumVertices(PWGM_HGRIDMODEL model, PWP_UINT32 ndx);
 
 
PW_DLLEXPORT PWP_UINT32
PwModVertexCount(PWGM_HGRIDMODEL model);
 
 
PW_DLLEXPORT PWP_BOOL
PwModCustomIndexSchemeReady(PWGM_HGRIDMODEL model, PWGM_INDEXMAPPERCB cb,
    void *cbData);
 
 
PW_DLLEXPORT PWP_BOOL
PwModStreamFaces(PWGM_HGRIDMODEL model, PWGM_ENUM_FACEORDER order,
                 PWGM_BEGINSTREAMCB beginCB, PWGM_FACESTREAMCB faceCB,
                 PWGM_ENDSTREAMCB endCB, void *userData);
 
 
PW_DLLEXPORT inline PWP_BOOL
PwModStreamFacesAnyOrder(const PWGM_HGRIDMODEL model, PWGM_BEGINSTREAMCB beginCB,
    PWGM_FACESTREAMCB faceCB, PWGM_ENDSTREAMCB endCB, void* userData)
{
    return PwModStreamFaces(model, PWGM_FACEORDER_DONTCARE, beginCB, faceCB,
        endCB, userData);
}
 
 
PW_DLLEXPORT inline PWP_BOOL
PwModStreamBoundaryFacesOnly(const PWGM_HGRIDMODEL model,
    PWGM_BEGINSTREAMCB beginCB, PWGM_FACESTREAMCB faceCB,
    PWGM_ENDSTREAMCB endCB, void* userData)
{
    return PwModStreamFaces(model, PWGM_FACEORDER_BOUNDARYONLY, beginCB, faceCB,
        endCB, userData);
}
 
 
PW_DLLEXPORT PWP_UINT32
PwModEnumElementCount(PWGM_HGRIDMODEL model, PWGM_ELEMCOUNTS *pCounts);
 
 
PW_DLLEXPORT PWGM_HELEMENT
PwModEnumElements(PWGM_HGRIDMODEL model, PWP_UINT32 ndx);
 
 
PW_DLLEXPORT PWP_BOOL
PwModAppendEnumElementOrder(PWGM_HGRIDMODEL model, PWGM_ENUM_ELEMORDER order);
 
 
PW_DLLEXPORT PWP_VOID
PwModDefaultEnumElementOrder(PWGM_HGRIDMODEL model);
 
 
PW_DLLEXPORT PWP_UINT32
PwBlkElementCount(PWGM_HBLOCK block, PWGM_ELEMCOUNTS *pCounts);
 
 
PW_DLLEXPORT inline PWP_UINT32
PwModNdxBlkElementCount(const PWGM_HGRIDMODEL model, const PWP_UINT32 ndx,
    PWGM_ELEMCOUNTS *pCounts)
{
    return PwBlkElementCount(PwModEnumBlocks(model, ndx), pCounts);
}
 
 
PW_DLLEXPORT PWGM_HELEMENT
PwBlkEnumElements(PWGM_HBLOCK block, PWP_UINT32 ndx);
 
 
PW_DLLEXPORT PWP_UINT32
PwDomElementCount(PWGM_HDOMAIN domain, PWGM_ELEMCOUNTS *pCounts);
 
 
PW_DLLEXPORT PWGM_HELEMENT
PwDomEnumElements(PWGM_HDOMAIN domain, PWP_UINT32 ndx);
 
 
PW_DLLEXPORT PWP_BOOL
PwDomCondition(PWGM_HDOMAIN domain, PWGM_CONDDATA *pCondData);
 
 
PW_DLLEXPORT inline PWP_BOOL
PwModNdxDomCondition(const PWGM_HGRIDMODEL model, const PWP_UINT32 ndx,
    PWGM_CONDDATA* pCondData)
{
    return PwDomCondition(PwModEnumDomains(model, ndx), pCondData);
}
 
 
PW_DLLEXPORT PWP_BOOL
PwVertDataMod(PWGM_HVERTEX vertex, PWGM_VERTDATA *pVertData);
 
 
PW_DLLEXPORT inline PWP_BOOL
PwModNdxVertDataMod(const PWGM_HGRIDMODEL model, const PWP_UINT32 ndx,
    PWGM_VERTDATA* pVertData)
{
    return PwVertDataMod(PwModEnumVertices(model, ndx), pVertData);
}
 
 
PW_DLLEXPORT PWP_BOOL
PwVertIndexMod(PWGM_HVERTEX vertex, PWP_UINT32 *pIndex);
 
 
PW_DLLEXPORT PWP_BOOL
PwVertXyzVal(PWGM_HVERTEX vertex, PWGM_ENUM_XYZ which, PWGM_XYZVAL *pVal);
 
 
PW_DLLEXPORT PWP_BOOL
PwElemDataMod(PWGM_HELEMENT element, PWGM_ELEMDATA *pElemData);
 
 
PW_DLLEXPORT inline PWP_BOOL
PwBlkNdxElemDataMod(const PWGM_HBLOCK block, const PWP_UINT32 ndx,
    PWGM_ELEMDATA *pElemData)
{
    return PwElemDataMod(PwBlkEnumElements(block, ndx), pElemData);
}
 
 
PW_DLLEXPORT inline PWP_BOOL
PwDomNdxElemDataMod(const PWGM_HDOMAIN domain, const PWP_UINT32 ndx,
    PWGM_ELEMDATA *pElemData)
{
    return PwElemDataMod(PwDomEnumElements(domain, ndx), pElemData);
}
 
 
PW_DLLEXPORT inline PWP_BOOL
PwModNdxElemDataMod(const PWGM_HGRIDMODEL model, const PWP_UINT32 ndx,
    PWGM_ELEMDATA *pElemData)
{
    return PwElemDataMod(PwModEnumElements(model, ndx), pElemData);
}
 
 
PW_DLLEXPORT PWP_BOOL
PwElemDataModEnum(PWGM_HELEMENT element, PWGM_ENUMELEMDATA *pElemData);
 
 
PW_DLLEXPORT inline PWP_BOOL
PwModNdxElemDataModEnum(const PWGM_HGRIDMODEL model, const PWP_UINT32 ndx,
    PWGM_ENUMELEMDATA* pElemData)
{
    return PwElemDataModEnum(PwModEnumElements(model, ndx), pElemData);
}
 
 
PW_DLLEXPORT PWP_BOOL
PwElemDataCastToPoly(const PWGM_ELEMDATA *eData, PWGM_POLYELEMDATA *polyData);
 
 
const char *
PwFaceOrderToText(PWGM_ENUM_FACEORDER faceOrder);
 
 
const char *
PwElemTypeToText(PWGM_ENUM_ELEMTYPE type);
 
#endif // !defined(PWGM_HIDE_UNSTRUCTURED_API) && !defined(PWGM_HIDE_EXPORT_API)
 
/***********************************************************/
#if !defined(PWGM_HIDE_STRUCTURED_API) && !defined(PWGM_HIDE_EXPORT_API)
 
PW_DLLEXPORT PWP_BOOL
PwBlkSize(PWGM_HBLOCK block, PWGM_STR_SIZE *pSize);
 
 
PW_DLLEXPORT PWP_BOOL
PwBlkNdxVertData(PWGM_HBLOCK block, PWGM_INDEX3 ndx3, PWGM_VERTDATA *pVertData);
 
 
PW_DLLEXPORT PWP_BOOL
PwModCustomIndex3SchemeReady(PWGM_HGRIDMODEL model, PWGM_INDEX3MAPPERCB cb,
    void *cbData);
 
 
PW_DLLEXPORT PWP_UINT32
PwModConnectionCount(PWGM_HGRIDMODEL model);
 
 
PW_DLLEXPORT PWGM_HCNXN
PwModEnumConnections(PWGM_HGRIDMODEL model, PWP_UINT32 ndx);
 
 
PW_DLLEXPORT PWP_BOOL
PwConnection(PWGM_HCNXN connection, PWGM_CNXNDATA *pCnxnData);
 
 
PW_DLLEXPORT PWP_BOOL
PwModNdxConnection(PWGM_HGRIDMODEL model, PWP_UINT32 ndx, PWGM_CNXNDATA *pCnxnData);
 
 
PW_DLLEXPORT PWP_UINT32
PwModBoundaryCount(PWGM_HGRIDMODEL model);
 
 
PW_DLLEXPORT PWGM_HBNDRY
PwModEnumBoundaries(PWGM_HGRIDMODEL model, PWP_UINT32 ndx);
 
 
PW_DLLEXPORT PWP_BOOL
PwBoundary(PWGM_HBNDRY boundary, PWGM_BNDRYDATA *pBndryData);
 
 
PW_DLLEXPORT PWP_BOOL
PwBndryCondition(PWGM_HBNDRY boundary, PWGM_CONDDATA *pCondData);
 
 
PW_DLLEXPORT PWP_BOOL
PwModNdxBoundary(PWGM_HGRIDMODEL model, PWP_UINT32 ndx, PWGM_BNDRYDATA *pBndryData);
 
 
PW_DLLEXPORT PWP_BOOL
PwModNdxBoundaryAndCondition(PWGM_HGRIDMODEL model, PWP_UINT32 ndx,
    PWGM_BNDRYDATA *pBndryData, PWGM_CONDDATA *pCondData);
 
 
PW_DLLEXPORT PWP_UINT32
PwBlkBoundaryCount(PWGM_HBLOCK block);
 
 
PW_DLLEXPORT PWGM_HBNDRY
PwBlkEnumBoundaries(PWGM_HBLOCK block, PWP_UINT32 ndx);
 
 
PW_DLLEXPORT PWP_BOOL
PwBlkNdxBoundary(PWGM_HBLOCK block, PWP_UINT32 ndx, PWGM_BNDRYDATA *pBndryData);
 
 
PW_DLLEXPORT PWP_BOOL
PwBlkNdxBoundaryAndCondition(PWGM_HBLOCK block, PWP_UINT32 ndx,
    PWGM_BNDRYDATA *pBndryData, PWGM_CONDDATA *pCondData);
 
 
PW_DLLEXPORT PWP_UINT32
PwBlkConnectionCount(PWGM_HBLOCK block);
 
 
PW_DLLEXPORT PWGM_HCNXN
PwBlkEnumConnections(PWGM_HBLOCK block, PWP_UINT32 ndx);
 
 
PW_DLLEXPORT PWP_BOOL
PwBlkNdxConnection(PWGM_HBLOCK block, PWP_UINT32 ndx,
    PWGM_CNXNDATA *pCnxnData);
 
 
/***********************************************************/
PWP_BOOL
PwXform2to3(const PWGM_INDEX_XFORM2 *pX2, PWGM_INDEX_XFORM *pX3);
 
 
PWP_BOOL
PwXform3to2(const PWGM_INDEX_XFORM *pX3, PWGM_INDEX_XFORM2 *pX2);
 
 
PWGM_INDEX3
PwXformApply(const PWGM_INDEX_XFORM *pX3, PWGM_INDEX3 ijk);
 
 
PWGM_ENUM_IJK
PwXformFollows(const PWGM_INDEX_XFORM *pX3, PWGM_ENUM_IJK localAxis,
               PWP_BOOL *pFlipped);
 
 
PWGM_INDEX3
PwXform2Apply(const PWGM_INDEX_XFORM2 *pX2, PWGM_INDEX3 ijk);
 
 
PWGM_ENUM_IJK
PwXform2Follows(const PWGM_INDEX_XFORM2 *pX2, PWGM_ENUM_IJK localAxis,
                PWP_BOOL *pFlipped);
 
 
PWP_BOOL
PwInRange(PWGM_INDEX3 ijk, const PWGM_STR_RANGE *pRange);
 
#endif // !defined(PWGM_HIDE_STRUCTURED_API) && !defined(PWGM_HIDE_EXPORT_API)
 
/***********************************************************/
#if !defined(PWGM_HIDE_IMPORT_API)
 
/***********************************************************/
/*---------------------------------------------------------*/
PW_DLLEXPORT PWGM_HVERTEXLIST
PwBlkGetVertexList(PWGM_HBLOCK h);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWGM_HVERTEXLIST
PwDomGetVertexList(PWGM_HDOMAIN h);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWGM_HVERTEXLIST
PwConGetVertexList(PWGM_HCONNECTOR h);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwConSetName(PWGM_HCONNECTOR h, const char *name);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwBlkSetName(PWGM_HBLOCK h, const char *name);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwDomSetName(PWGM_HDOMAIN h, const char *name);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwVlstIsUnstructured(PWGM_HVERTEXLIST h);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwVlstIsStructured(PWGM_HVERTEXLIST h);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_UINT
PwVlstGetIndexDimensionality(PWGM_HVERTEXLIST h);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_ENUM_DIMENSION
PwVlstGetBlkElemDimensionality(PWGM_HVERTEXLIST h);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwVlstSetXYZVal(PWGM_HVERTEXLIST h, const PWP_UINT ndx,
    const PWGM_ENUM_XYZ which, const PWGM_XYZVAL val);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwVlstSetXYZ(PWGM_HVERTEXLIST h, const PWP_UINT ndx, const PWGM_XYZVAL x,
    const PWGM_XYZVAL y, const PWGM_XYZVAL z);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwVlstSetXYZData(PWGM_HVERTEXLIST h, const PWP_UINT ndx, const PWGM_VERTDATA &v);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwVlstSetXYZVal2(PWGM_HVERTEXLIST h, const PWGM_INDEX2 ndx2,
    const PWGM_ENUM_XYZ which, const PWGM_XYZVAL val);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwVlstSetXYZ2(PWGM_HVERTEXLIST h, const PWGM_INDEX2 ndx2, const PWGM_XYZVAL x,
    const PWGM_XYZVAL y, const PWGM_XYZVAL z);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwVlstSetXYZ2Data(PWGM_HVERTEXLIST h, const PWGM_INDEX2 ndx2,
    const PWGM_VERTDATA &v);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwVlstSetXYZVal3(PWGM_HVERTEXLIST h, const PWGM_INDEX3 ndx3,
    const PWGM_ENUM_XYZ which, const PWGM_XYZVAL val);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwVlstSetXYZ3(PWGM_HVERTEXLIST h, const PWGM_INDEX3 ndx3, const PWGM_XYZVAL x,
    const PWGM_XYZVAL y, const PWGM_XYZVAL z);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwVlstSetXYZ3Data(PWGM_HVERTEXLIST h, const PWGM_INDEX3 ndx3, const PWGM_VERTDATA &v);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwBlkSetProperty(PWGM_HBLOCK block, const char *key, const char *val);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwDomSetProperty(PWGM_HDOMAIN domain, const char *key, const char *val);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwConSetProperty(PWGM_HCONNECTOR connector, const char *key, const char *val);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwAsmSetProperty(PWGM_HBLOCKASSEMBLER assembler, const PWP_UINT32 propertySetId,
    const char *key, const char *val);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwBlkSetConditionUserName(PWGM_HBLOCK block, const char *userName);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwBlkSetConditionUserId(PWGM_HBLOCK block, const PWP_UINT32 userId);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwBlkSetConditionTypeName(PWGM_HBLOCK block, const char *typeName);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwBlkSetConditionTypeId(PWGM_HBLOCK block, const PWP_UINT32 typeId);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwBlkSetCondition(PWGM_HBLOCK block, const PWGM_CONDDATA &condData);
 
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwDomSetConditionUserName(PWGM_HDOMAIN domain, const char *userName);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwDomSetConditionUserId(PWGM_HDOMAIN domain, const PWP_UINT32 userId);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwDomSetConditionTypeName(PWGM_HDOMAIN domain, const char *typeName);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwDomSetConditionTypeId(PWGM_HDOMAIN domain, const PWP_UINT32 typeId);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwDomSetCondition(PWGM_HDOMAIN domain, const PWGM_CONDDATA &condData);
 
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwConSetConditionUserName(PWGM_HCONNECTOR connector, const char *userName);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwConSetConditionUserId(PWGM_HCONNECTOR connector, const PWP_UINT32 userId);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwConSetConditionTypeName(PWGM_HCONNECTOR connector, const char *typeName);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwConSetConditionTypeId(PWGM_HCONNECTOR connector, const PWP_UINT32 typeId);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwConSetCondition(PWGM_HCONNECTOR connector, const PWGM_CONDDATA &condData);
 
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwAsmSetConditionUserName(PWGM_HBLOCKASSEMBLER assembler,
    const PWGM_CONDKEY key, const char *userName);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwAsmSetConditionUserId(PWGM_HBLOCKASSEMBLER assembler, const PWGM_CONDKEY key,
    const PWP_UINT32 userId);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwAsmSetConditionTypeName(PWGM_HBLOCKASSEMBLER assembler,
    const PWGM_CONDKEY key, const char *typeName);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwAsmSetConditionTypeId(PWGM_HBLOCKASSEMBLER assembler, const PWGM_CONDKEY key,
    const PWP_UINT32 typeId);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwAsmSetCondition(PWGM_HBLOCKASSEMBLER assembler, const PWGM_CONDKEY key,
    const PWGM_CONDDATA &condData);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwAsmSetCellSpanConditionKey(PWGM_HBLOCKASSEMBLER assembler,
    const PWGM_CONDKEY key, const PWP_UINT32 startCell,
    const PWP_UINT32 endCell);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwAsmSetCellConditionKey(PWGM_HBLOCKASSEMBLER assembler, const PWGM_CONDKEY key,
    const PWP_UINT32 cell);
 
 
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwVlstReadFile(PWGM_HVERTEXLIST h, FILE *file,
    const PWGM_XYZ_CLUSTERING fileClustering,
    const PWP_ENDIANNESS fileByteOrder, const PWP_ENUM_PRECISION filePrecision);
 
/***********************************************************/
/*---------------------------------------------------------*/
PW_DLLEXPORT PWGM_HVERTEXLIST
PwModCreateUnsVertexList(PWGM_HGRIDMODEL model,
    const PWP_ENUM_DIMENSION blkElemDimty);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWGM_HVERTEXLIST
PwModCreateUnsVertexList3(PWGM_HGRIDMODEL model);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWGM_HVERTEXLIST
PwModCreateUnsVertexList2(PWGM_HGRIDMODEL model);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwVlstAllocate(PWGM_HVERTEXLIST h, const PWP_UINT count);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWGM_HBLOCK
PwVlstCreateUnsBlock(PWGM_HVERTEXLIST h);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwUnsBlkAllocateElements(PWGM_HBLOCK h, const PWGM_ENUM_ELEMTYPE cellType,
    const PWP_UINT count);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwUnsBlkAllocateElementCounts(PWGM_HBLOCK h, const PWGM_ELEMCOUNTS &counts);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwUnsBlkSetElement(PWGM_HBLOCK h, const PWP_UINT ndx, const PWGM_ELEMDATA *eData);
 
/*---------------------------------------------------------*/
 
PW_DLLEXPORT PWGM_HDOMAIN
PwVlstCreateUnsDomain(PWGM_HVERTEXLIST h);
 
PW_DLLEXPORT PWGM_HDOMAIN
PwVlstCreateUnsBoundary(PWGM_HVERTEXLIST h);
 
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwUnsDomAllocateElements(PWGM_HDOMAIN h, const PWGM_ENUM_ELEMTYPE cellType,
    const PWP_UINT count);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwUnsDomAllocateElementCounts(PWGM_HDOMAIN h, const PWGM_ELEMCOUNTS &counts);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwUnsDomSetElement(PWGM_HDOMAIN h, const PWP_UINT ndx,
    const PWGM_ELEMDATA *eData);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWGM_HBLOCKASSEMBLER
PwVlstCreateBlockAssembler(PWGM_HVERTEXLIST h);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwAsmPushElementFace(PWGM_HBLOCKASSEMBLER h, const PWGM_ASSEMBLER_DATA *face);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWP_BOOL
PwAsmFinalize(PWGM_HBLOCKASSEMBLER h);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWGM_HVERTEXLIST
PwAsmGetVertexList(PWGM_HBLOCKASSEMBLER h);
 
/***********************************************************/
/*---------------------------------------------------------*/
PW_DLLEXPORT PWGM_HCONNECTOR
PwModCreateCon(PWGM_HGRIDMODEL model, PWP_UINT size);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWGM_HBLOCK
PwModCreateStrBlock(PWGM_HGRIDMODEL model, const PWGM_STR_SIZE blkSize);
 
/*---------------------------------------------------------*/
PW_DLLEXPORT PWGM_HDOMAIN
PwModCreateStrDomain(PWGM_HGRIDMODEL model, const PWGM_STR_SIZE domSize);
 
#endif // !defined(PWGM_HIDE_IMPORT_API)
 
/*---------------------------------------------------------*/
/*              COMMON GRID EXPORT CALLBACKS               */
/*---------------------------------------------------------*/
 
typedef PWP_UINT32
PwModBlockCount_t(PWGM_HGRIDMODEL model);
 
typedef PWGM_HBLOCK
PwModEnumBlocks_t(PWGM_HGRIDMODEL model, PWP_UINT32 ndx);
 
typedef PWP_BOOL
PwBlkCondition_t(PWGM_HBLOCK block, PWGM_CONDDATA *pCondData);
 
typedef PWP_BOOL
PwBlock_t(PWGM_HBLOCK block, PWGM_BLOCKDATA *pBlockData);
 
typedef PWP_BOOL
PwBlkSetExportName_t(PWGM_HBLOCK block, const char *name);
 
typedef PWP_BOOL
PwModGetAttributeValue_t(PWGM_HGRIDMODEL model, const char *name,
    PWP_ENUM_VALTYPE bufType, void *buf, PWP_UINT count);
 
 
/*---------------------------------------------------------*/
/*           UNSTRUCTURED GRID EXPORT CALLBACKS            */
/*---------------------------------------------------------*/
 
typedef PWP_UINT32
PwModDomainCount_t(PWGM_HGRIDMODEL model);
 
typedef PWGM_HDOMAIN
PwModEnumDomains_t(PWGM_HGRIDMODEL model, PWP_UINT32 ndx);
 
typedef PWGM_HVERTEX
PwModEnumVertices_t(PWGM_HGRIDMODEL model, PWP_UINT32 ndx);
 
typedef PWP_UINT32
PwModVertexCount_t(PWGM_HGRIDMODEL model);
 
typedef PWP_BOOL
PwModCustomIndexSchemeReady_t(PWGM_HGRIDMODEL model, PWGM_INDEXMAPPERCB cb,
                              void *data);
 
typedef PWP_BOOL
PwModStreamFaces_t(PWGM_HGRIDMODEL model, PWGM_ENUM_FACEORDER order,
                   PWGM_BEGINSTREAMCB beginCB, PWGM_FACESTREAMCB faceCB,
                   PWGM_ENDSTREAMCB endCB, void *userData);
 
typedef PWP_UINT32
PwModEnumElementCount_t(PWGM_HGRIDMODEL model, PWGM_ELEMCOUNTS *pCounts);
 
typedef PWP_BOOL
PwModAppendEnumElementOrder_t(PWGM_HGRIDMODEL model, PWGM_ENUM_ELEMORDER order);
 
typedef PWGM_HELEMENT
PwModEnumElements_t(PWGM_HGRIDMODEL model, PWP_UINT32 ndx);
 
//---------------------------
typedef PWP_UINT32
PwBlkElementCount_t(PWGM_HBLOCK block, PWGM_ELEMCOUNTS *pCounts);
 
typedef PWGM_HELEMENT
PwBlkEnumElements_t(PWGM_HBLOCK block, PWP_UINT32 ndx);
 
//---------------------------
typedef PWP_UINT32
PwDomElementCount_t(PWGM_HDOMAIN domain, PWGM_ELEMCOUNTS *pCounts);
 
typedef PWGM_HELEMENT
PwDomEnumElements_t(PWGM_HDOMAIN domain, PWP_UINT32 ndx);
 
typedef PWP_BOOL
PwDomCondition_t(PWGM_HDOMAIN domain, PWGM_CONDDATA *pCondData);
 
//---------------------------
typedef PWP_BOOL
PwVertDataMod_t(PWGM_HVERTEX vertex, PWGM_VERTDATA *pVertData);
 
typedef PWP_BOOL
PwVertIndexMod_t(PWGM_HVERTEX vertex, PWP_UINT32 *pIndex);
 
typedef PWP_BOOL
PwVertXyzVal_t(PWGM_HVERTEX vertex, PWGM_ENUM_XYZ which, PWGM_XYZVAL *pVal);
 
//---------------------------
typedef PWP_BOOL
PwElemDataMod_t(PWGM_HELEMENT element, PWGM_ELEMDATA *pElemData);
 
typedef PWP_BOOL
PwElemDataModEnum_t(PWGM_HELEMENT element, PWGM_ENUMELEMDATA *pElemData);
 
 
 
/*---------------------------------------------------------*/
/*           STRUCTURED GRID EXPORT CALLBACKS              */
/*---------------------------------------------------------*/
 
typedef PWP_UINT32
PwModBoundaryCount_t(PWGM_HGRIDMODEL model);
 
typedef PWGM_HBNDRY
PwModEnumBoundaries_t(PWGM_HGRIDMODEL model, PWP_UINT32 ndx);
 
typedef PWP_UINT32
PwModConnectionCount_t(PWGM_HGRIDMODEL model);
 
typedef PWGM_HCNXN
PwModEnumConnections_t(PWGM_HGRIDMODEL model, PWP_UINT32 ndx);
 
typedef PWP_BOOL
PwModNdxBoundary_t(PWGM_HGRIDMODEL model, PWP_UINT32 ndx,
    PWGM_BNDRYDATA *pBndryData);
 
typedef PWP_BOOL
PwModNdxBoundaryAndCondition_t(PWGM_HGRIDMODEL model, PWP_UINT32 ndx,
    PWGM_BNDRYDATA *pBndryData, PWGM_CONDDATA *pCondData);
 
typedef PWP_BOOL
PwModNdxConnection_t(PWGM_HGRIDMODEL model, PWP_UINT32 ndx,
    PWGM_CNXNDATA *pCnxnData);
 
//---------------------------
typedef PWP_BOOL
PwBlkSize_t(PWGM_HBLOCK block, PWGM_STR_SIZE *pSize);
 
typedef PWP_BOOL
PwBlkNdxVertData_t(PWGM_HBLOCK block, PWGM_INDEX3 ndx3,
    PWGM_VERTDATA *pVertData);
 
typedef PWP_BOOL
PwModCustomIndex3SchemeReady_t(PWGM_HGRIDMODEL model, PWGM_INDEX3MAPPERCB cb,
    void *data);
 
typedef PWP_UINT32
PwBlkBoundaryCount_t(PWGM_HBLOCK block);
 
typedef PWGM_HBNDRY
PwBlkEnumBoundaries_t(PWGM_HBLOCK block, PWP_UINT32 ndx);
 
typedef PWP_UINT32
PwBlkConnectionCount_t(PWGM_HBLOCK block);
 
typedef PWGM_HCNXN
PwBlkEnumConnections_t(PWGM_HBLOCK block, PWP_UINT32 ndx);
 
typedef PWP_BOOL
PwBlkNdxBoundary_t(PWGM_HBLOCK block, PWP_UINT32 ndx,
    PWGM_BNDRYDATA *pBndryData);
 
typedef PWP_BOOL
PwBlkNdxBoundaryAndCondition_t(PWGM_HBLOCK block, PWP_UINT32 ndx,
    PWGM_BNDRYDATA *pBndryData, PWGM_CONDDATA *pCondData);
 
typedef PWP_BOOL
PwBlkNdxConnection_t(PWGM_HBLOCK block, PWP_UINT32 ndx,
    PWGM_CNXNDATA *pCnxnData);
 
 
//---------------------------
typedef PWP_BOOL
PwBoundary_t(PWGM_HBNDRY boundary, PWGM_BNDRYDATA *pBndryData);
 
typedef PWP_BOOL
PwBndryCondition_t(PWGM_HBNDRY boundary, PWGM_CONDDATA *pCondData);
 
typedef PWP_BOOL
PwConnection_t(PWGM_HCNXN connection, PWGM_CNXNDATA *pCnxnData);
 
//---------------------------
typedef PWP_BOOL
PwNOTIMPLEMENTED_t();
 
 
/*---------------------------------------------------------*/
/*             COMMON GRID IMPORT CALLBACKS                */
/*---------------------------------------------------------*/
 
typedef PWGM_HCONNECTOR
PwModCreateCon_t(PWGM_HGRIDMODEL model, PWP_UINT size);
 
typedef PWGM_HVERTEXLIST
PwBlkGetVertexList_t(PWGM_HBLOCK h);
 
typedef PWGM_HVERTEXLIST
PwDomGetVertexList_t(PWGM_HDOMAIN h);
 
typedef PWGM_HVERTEXLIST
PwConGetVertexList_t(PWGM_HCONNECTOR h);
 
typedef PWP_BOOL
PwConSetName_t(PWGM_HCONNECTOR h, const char *name);
 
typedef PWP_BOOL
PwBlkSetName_t(PWGM_HBLOCK h, const char *name);
 
typedef PWP_BOOL
PwDomSetName_t(PWGM_HDOMAIN h, const char *name);
 
typedef PWP_BOOL
PwVlstIsUnstructured_t(PWGM_HVERTEXLIST h);
 
typedef PWP_UINT
PwVlstGetIndexDimensionality_t(PWGM_HVERTEXLIST h);
 
typedef PWP_ENUM_DIMENSION
PwVlstGetBlkElemDimensionality_t(PWGM_HVERTEXLIST h);
 
typedef PWP_BOOL
PwVlstSetXYZVal3_t(PWGM_HVERTEXLIST h, const PWGM_INDEX3 ndx3,
    const PWGM_ENUM_XYZ which, const PWGM_XYZVAL val);
 
typedef PWP_BOOL
PwVlstSetXYZ3_t(PWGM_HVERTEXLIST h, const PWGM_INDEX3 ndx3,
    const PWGM_XYZVAL x, const PWGM_XYZVAL y, const PWGM_XYZVAL z);
 
typedef PWP_BOOL
PwVlstReadFile_t(PWGM_HVERTEXLIST h, FILE *file,
    const PWGM_XYZ_CLUSTERING fileClustering,
    const PWP_ENDIANNESS fileByteOrder, const PWP_ENUM_PRECISION filePrecision);
 
typedef PWP_BOOL
PwBlkSetProperty_t(PWGM_HBLOCK h, const char *key, const char *val);
 
typedef PWP_BOOL
PwDomSetProperty_t(PWGM_HDOMAIN h, const char *key, const char *val);
 
typedef PWP_BOOL
PwConSetProperty_t(PWGM_HCONNECTOR h, const char *key, const char *val);
 
typedef PWP_BOOL
PwAsmSetProperty_t(PWGM_HBLOCKASSEMBLER h, const PWP_UINT32 propertySetId,
    const char *key, const char *val);
 
typedef PWP_BOOL
PwAsmSetCellSpanConditionKey_t(PWGM_HBLOCKASSEMBLER assembler,
    const PWGM_CONDKEY key, const PWP_UINT32 startCell,
    const PWP_UINT32 endCell);
 
 
/*---------------------------------------------------------*/
/*          UNSTRUCTURED GRID IMPORT CALLBACKS             */
/*---------------------------------------------------------*/
 
typedef PWGM_HVERTEXLIST
PwModCreateUnsVertexList_t(PWGM_HGRIDMODEL model,
    const PWP_ENUM_DIMENSION blkElemDimty);
 
typedef PWP_BOOL
PwVlstAllocate_t(PWGM_HVERTEXLIST h, const PWP_UINT count);
 
typedef PWGM_HBLOCK
PwVlstCreateUnsBlock_t(PWGM_HVERTEXLIST h);
 
typedef PWP_BOOL
PwUnsBlkAllocateElements_t(PWGM_HBLOCK h, const PWGM_ENUM_ELEMTYPE cellType,
    const PWP_UINT count);
 
typedef PWP_BOOL
PwUnsBlkSetElement_t(PWGM_HBLOCK h, const PWP_UINT ndx,
    const PWGM_ELEMDATA *eData);
 
typedef PWGM_HDOMAIN
PwVlstCreateUnsDomain_t(PWGM_HVERTEXLIST h);
 
typedef PWP_BOOL
PwUnsDomAllocateElements_t(PWGM_HDOMAIN h, const PWGM_ENUM_ELEMTYPE cellType,
    const PWP_UINT count);
 
typedef PWP_BOOL
PwUnsDomSetElement_t(PWGM_HDOMAIN h, const PWP_UINT ndx,
    const PWGM_ELEMDATA *eData);
 
typedef PWGM_HBLOCKASSEMBLER
PwVlstCreateBlockAssembler_t(PWGM_HVERTEXLIST h);
 
typedef PWP_BOOL
PwAsmPushElementFace_t(PWGM_HBLOCKASSEMBLER h, const PWGM_ASSEMBLER_DATA *face);
 
typedef PWP_BOOL
PwAsmFinalize_t(PWGM_HBLOCKASSEMBLER h);
 
typedef PWGM_HVERTEXLIST
PwAsmGetVertexList_t(PWGM_HBLOCKASSEMBLER h);
 
 
/*---------------------------------------------------------*/
/*           STRUCTURED GRID IMPORT CALLBACKS              */
/*---------------------------------------------------------*/
 
typedef PWGM_HBLOCK
PwModCreateStrBlock_t(PWGM_HGRIDMODEL model, const PWGM_STR_SIZE blkSize);
 
typedef PWGM_HDOMAIN
PwModCreateStrDomain_t(PWGM_HGRIDMODEL model, const PWGM_STR_SIZE domSize);
 
 
 
// PWGM-API function-pointer types
 
struct PW_DLL_IMPEXP PWGM_HGRIDMODEL_OUT_IMPL {
    PwModBlockCount_t *             PwModBlockCountCB;
    PwModDomainCount_t *            PwModDomainCountCB;
    PwModEnumBlocks_t *             PwModEnumBlocksCB;
    PwModEnumDomains_t *            PwModEnumDomainsCB;
    PwModEnumVertices_t *           PwModEnumVerticesCB;
    PwModVertexCount_t *            PwModVertexCountCB;
    PwModCustomIndexSchemeReady_t * PwModCustomIndexSchemeReadyCB;
 
    PwBlkElementCount_t *           PwBlkElementCountCB;
    PwBlkEnumElements_t *           PwBlkEnumElementsCB;
    PwNOTIMPLEMENTED_t *            PwBlkEnumVerticesCB;
    PwNOTIMPLEMENTED_t *            PwBlkVertexCountCB;
    PwBlkCondition_t *              PwBlkConditionCB;
    PwBlock_t *                     PwBlockCB;
    PwBlkSetExportName_t *          PwBlkSetExportNameCB;
 
    PwDomElementCount_t *           PwDomElementCountCB;
    PwDomEnumElements_t *           PwDomEnumElementsCB;
    PwNOTIMPLEMENTED_t *            PwDomEnumVerticesCB;
    PwNOTIMPLEMENTED_t *            PwDomVertexCountCB;
    PwDomCondition_t *              PwDomConditionCB;
 
    PwVertDataMod_t *               PwVertDataModCB;
    PwNOTIMPLEMENTED_t *            PwVertDataBlkCB;
    PwNOTIMPLEMENTED_t *            PwVertDataDomCB;
    PwVertIndexMod_t *              PwVertIndexModCB;
    PwNOTIMPLEMENTED_t *            PwVertIndexBlkCB;
    PwNOTIMPLEMENTED_t *            PwVertIndexDomCB;
    PwVertXyzVal_t *                PwVertXyzValCB;
 
    PwElemDataMod_t *               PwElemDataModCB;
    PwNOTIMPLEMENTED_t *            PwElemDataBlkCB;
    PwNOTIMPLEMENTED_t *            PwElemDataDomCB;
 
    /*---------------------------------------------------------*/
    /*               STRUCTURED GRID ADDITIONS                 */
    /*---------------------------------------------------------*/
 
    PwModBoundaryCount_t *              PwModBoundaryCountCB;
    PwModEnumBoundaries_t *             PwModEnumBoundariesCB;
    PwModConnectionCount_t *            PwModConnectionCountCB;
    PwModEnumConnections_t *            PwModEnumConnectionsCB;
    PwModNdxBoundary_t *                PwModNdxBoundaryCB;
    PwModNdxBoundaryAndCondition_t *    PwModNdxBoundaryAndConditionCB;
    PwModNdxConnection_t *              PwModNdxConnectionCB;
 
    PwBlkSize_t *                       PwBlkSizeCB;
    PwBlkNdxVertData_t *                PwBlkNdxVertDataCB;
    PwModCustomIndex3SchemeReady_t *    PwModCustomIndex3SchemeReadyCB;
    PwBlkBoundaryCount_t *              PwBlkBoundaryCountCB;
    PwBlkEnumBoundaries_t *             PwBlkEnumBoundariesCB;
    PwBlkConnectionCount_t *            PwBlkConnectionCountCB;
    PwBlkEnumConnections_t *            PwBlkEnumConnectionsCB;
    PwBlkNdxBoundary_t *                PwBlkNdxBoundaryCB;
    PwBlkNdxBoundaryAndCondition_t *    PwBlkNdxBoundaryAndConditionCB;
    PwBlkNdxConnection_t *              PwBlkNdxConnectionCB;
 
    PwBoundary_t *                      PwBoundaryCB;
    PwBndryCondition_t *                PwBndryConditionCB;
    PwConnection_t *                    PwConnectionCB;
 
    /*---------------------------------------------------------*/
    /*               CELL FACE STREAMING ADDITIONS             */
    /*---------------------------------------------------------*/
 
    PwModStreamFaces_t *                PwModStreamFacesCB;
    PwModEnumElementCount_t *           PwModEnumElementCountCB;
    PwModEnumElements_t *               PwModEnumElementsCB;
    PwElemDataModEnum_t *               PwElemDataModEnumCB;
    PwModAppendEnumElementOrder_t *     PwModAppendEnumElementOrderCB;
 
    /*---------------------------------------------------------*/
    /*               SOLVER ATTRIBUTE ADDITIONS                */
    /*---------------------------------------------------------*/
 
    PwModGetAttributeValue_t *          PwModGetAttributeValueCB;
};
 
 
/*---------------------------------------------------------*/
struct PW_DLL_IMPEXP PWGM_HGRIDMODEL_IN_IMPL {
 
    // Common Grid Model Import API Calls
    PwModCreateCon_t *                  PwModCreateConCB;
    PwBlkGetVertexList_t *              PwBlkGetVertexListCB;
    PwDomGetVertexList_t *              PwDomGetVertexListCB;
    PwConGetVertexList_t *              PwConGetVertexListCB;
    PwConSetName_t *                    PwConSetNameCB;
    PwBlkSetName_t *                    PwBlkSetNameCB;
    PwDomSetName_t *                    PwDomSetNameCB;
    PwVlstIsUnstructured_t *            PwVlstIsUnstructuredCB;
    PwVlstGetIndexDimensionality_t *    PwVlstGetIndexDimensionalityCB;
    PwVlstGetBlkElemDimensionality_t *  PwVlstGetBlkElemDimensionalityCB;
    PwVlstSetXYZVal3_t *                PwVlstSetXYZVal3CB;
    PwVlstSetXYZ3_t *                   PwVlstSetXYZ3CB;
    PwVlstReadFile_t *                  PwVlstReadFileCB;
    PwBlkSetProperty_t *                PwBlkSetPropertyCB;
    PwDomSetProperty_t *                PwDomSetPropertyCB;
    PwConSetProperty_t *                PwConSetPropertyCB;
    PwAsmSetProperty_t *                PwAsmSetPropertyCB;
    PwAsmSetCellSpanConditionKey_t *    PwAsmSetCellSpanConditionKeyCB;
 
 
    // Unstructured Grid Model Import API Calls
    PwModCreateUnsVertexList_t *        PwModCreateUnsVertexListCB;
    PwVlstAllocate_t *                  PwVlstAllocateCB;
    PwVlstCreateUnsBlock_t *            PwVlstCreateUnsBlockCB;
    PwUnsBlkAllocateElements_t *        PwUnsBlkAllocateElementsCB;
    PwUnsBlkSetElement_t *              PwUnsBlkSetElementCB;
    PwVlstCreateUnsDomain_t *           PwVlstCreateUnsDomainCB;
    PwUnsDomAllocateElements_t *        PwUnsDomAllocateElementsCB;
    PwUnsDomSetElement_t *              PwUnsDomSetElementCB;
    PwVlstCreateBlockAssembler_t *      PwVlstCreateBlockAssemblerCB;
    PwAsmPushElementFace_t *            PwAsmPushElementFaceCB;
    PwAsmFinalize_t *                   PwAsmFinalizeCB;
    PwAsmGetVertexList_t *              PwAsmGetVertexListCB;
 
    // Structured Grid Model Import API Calls
    PwModCreateStrBlock_t *             PwModCreateStrBlockCB;
    PwModCreateStrDomain_t *            PwModCreateStrDomainCB;
};
 // sdkINTERNALS
 
/***********************************************************/
} // extern "C"
 
#endif // !_APIGRIDMODEL_H_