apiGridModel.cxx

Go to the documentation of this file.

/****************************************************************************
 *
 * CAEP Plugin example
 *
 * (C) 2021 Cadence Design Systems, Inc. All rights reserved worldwide.
 *
 ***************************************************************************/
 
// See comments in core code for information on adding new PWGM API functions.
 
#include <cctype>
#include <climits>
#include <cerrno>
#include <sstream>
#include <string>
 
// Define these on the build command line for verbose build messages
// #define SHOW_PWP_MESSAGES
// #define SHOW_PWGM_MESSAGES
#include "apiGridModel.h"
 
#include "apiPWPUtils.h"
 
// If this asserts, PWGM_ASSEMBLER_DATA has increased in size! This will
// increase memory usage during face grid importing. Are you sure?
ASSERT_COMPILE(sizeof(PWGM_ASSEMBLER_DATA) <= sizeof(PWP_UINT32) * 8);
 
#define MODEL_OUT       PWGM_HGRIDMODEL_OUT_GMIMPL(model)
#define BLKMODEL_OUT    PWGM_HBLOCK_OUT_GMIMPL(block)
#define DOMMODEL_OUT    PWGM_HDOMAIN_OUT_GMIMPL(domain)
#define VERTMODEL_OUT   PWGM_HVERTEX_OUT_GMIMPL(vertex)
#define ELEMMODEL_OUT   PWGM_HELEMENT_OUT_GMIMPL(element)
#define BNDRYMODEL_OUT  PWGM_HBNDRY_OUT_GMIMPL(boundary)
#define CNXNMODEL_OUT   PWGM_HCNXN_OUT_GMIMPL(connection)
 
#define MODEL_IN       PWGM_HGRIDMODEL_IN_GMIMPL(model)
#define BLKMODEL_IN    PWGM_HBLOCK_IN_GMIMPL(block)
#define DOMMODEL_IN    PWGM_HDOMAIN_IN_GMIMPL(domain)
#define CONMODEL_IN    PWGM_HCONNECTOR_IN_GMIMPL(connector)
#define VLISTMODEL_IN  PWGM_HVERTEXLIST_IN_GMIMPL(vertlist)
#define BLKASMMODEL_IN PWGM_HBLOCKASSEMBLER_IN_GMIMPL(blkAsm)
 
static const PWGM_HBLOCK           badBlock = PWGM_HBLOCK_INIT;
static const PWGM_HDOMAIN          badDomain = PWGM_HDOMAIN_INIT;
 
#if !defined(PWGM_HIDE_IMPORT_API)
static const PWGM_HCONNECTOR       badConnector = PWGM_HCONNECTOR_INIT;
static const PWGM_HVERTEXLIST      badVertexList = PWGM_HVERTEXLIST_INIT;
static const PWGM_HBLOCKASSEMBLER  badAssembler = PWGM_HBLOCKASSEMBLER_INIT;
 
static const char *                 PropSubType{ "SubType" };
static const char *                 PropUserName{ "UserName" };
static const char *                 PropUserId{ "UserId" };
static const char *                 PropTypeName{ "TypeName" };
static const char *                 PropTypeId{ "TypeId" };
 
static const char *                 SubTypeBoundary{ "Boundary" };
 
#endif /* PWGM_HIDE_IMPORT_API */
 
#if !defined(PWGM_HIDE_UNSTRUCTURED_API)
static const PWGM_HVERTEX          badVertex = PWGM_HVERTEX_INIT;
static const PWGM_HELEMENT         badElement = PWGM_HELEMENT_INIT;
#endif /* PWGM_HIDE_UNSTRUCTURED_API */
 
#if !defined(PWGM_HIDE_STRUCTURED_API)
static const PWGM_HBNDRY           badBoundary = PWGM_HBNDRY_INIT;
static const PWGM_HCNXN            badConnection = PWGM_HCNXN_INIT;
#endif /* PWGM_HIDE_STRUCTURED_API */
 
 
#ifdef WINDOWS
#   define strcasecmp  stricmp
#   define strncasecmp strnicmp
#endif /* WINDOWS */
 
 
 
 
PWP_UINT32
PwModBlockCount(PWGM_HGRIDMODEL model)
{
    return (MODEL_OUT && MODEL_OUT->PwModBlockCountCB) ?
        MODEL_OUT->PwModBlockCountCB(model) : 0;
}
 
 
PWGM_HBLOCK
PwModEnumBlocks(PWGM_HGRIDMODEL model, PWP_UINT32 ndx)
{
    return (MODEL_OUT && MODEL_OUT->PwModEnumBlocksCB) ?
        MODEL_OUT->PwModEnumBlocksCB(model, ndx) : badBlock;
}
 
 
PWP_BOOL
PwBlkCondition(PWGM_HBLOCK block, PWGM_CONDDATA *pCondData)
{
    return (pCondData && PWGM_HBLOCK_ISVALID(block) && BLKMODEL_OUT &&
            BLKMODEL_OUT->PwBlkConditionCB) ?
        BLKMODEL_OUT->PwBlkConditionCB(block, pCondData) : PWP_FALSE;
}
 
 
PWP_BOOL
PwBlock(PWGM_HBLOCK block, PWGM_BLOCKDATA *pBlockData)
{
    return (pBlockData && PWGM_HBLOCK_ISVALID(block) && BLKMODEL_OUT &&
        BLKMODEL_OUT->PwBlockCB) ? BLKMODEL_OUT->PwBlockCB(block, pBlockData) :
        PWP_FALSE;
}
 
 
PWP_BOOL
PwBlkSetExportName(PWGM_HBLOCK block, const char *name)
{
    return (PWGM_HBLOCK_ISVALID(block) && BLKMODEL_OUT &&
        BLKMODEL_OUT->PwBlkSetExportNameCB) ?
        BLKMODEL_OUT->PwBlkSetExportNameCB(block, name) : PWP_FALSE;
}
 
 
PWP_BOOL
PwModGetAttributeValue(PWGM_HGRIDMODEL model, const char *name,
    PWP_ENUM_VALTYPE bufType, void *buf, PWP_UINT count)
{
    return (MODEL_OUT && MODEL_OUT->PwModGetAttributeValueCB) ?
        MODEL_OUT->PwModGetAttributeValueCB(model, name, bufType, buf, count) :
            PWP_FALSE;
}
 
 
PWP_BOOL
PwModGetAttributeString(PWGM_HGRIDMODEL model, const char *name,
    const char ** val)
{
    return PwModGetAttributeValue(model, name, PWP_VALTYPE_STRING, val, 1);
}
 
 
PWP_BOOL
PwModGetAttributeUINT(PWGM_HGRIDMODEL model, const char *name,
    PWP_UINT *val)
{
    return PwModGetAttributeValue(model, name, PWP_VALTYPE_UINT, val, 1);
}
 
 
PWP_BOOL
PwModGetAttributeUINT32(PWGM_HGRIDMODEL model, const char *name,
    PWP_UINT32 *val)
{
    PWP_UINT locVal = 0;
    PWP_BOOL ret = PwModGetAttributeUINT(model, name, &locVal);
    if (ret && val) {
        *val = (PWP_UINT32)locVal;
    }
    return ret;
}
 
 
PWP_BOOL
PwModGetAttributeINT(PWGM_HGRIDMODEL model, const char *name,
    PWP_INT *val)
{
    return PwModGetAttributeValue(model, name, PWP_VALTYPE_INT, val, 1);
}
 
 
PWP_BOOL
PwModGetAttributeINT32(PWGM_HGRIDMODEL model, const char *name,
    PWP_INT32 *val)
{
    PWP_INT locVal = 0;
    PWP_BOOL ret = val && PwModGetAttributeINT(model, name, &locVal);
    if (ret && val) {
        *val = (PWP_INT32)locVal;
    }
    return ret;
}
 
 
PWP_BOOL
PwModGetAttributeREAL(PWGM_HGRIDMODEL model, const char *name,
    PWP_REAL *val)
{
    return PwModGetAttributeValue(model, name, PWP_VALTYPE_REAL, val, 1);
}
 
 
PWP_BOOL
PwModGetAttributeFLOAT(PWGM_HGRIDMODEL model, const char *name,
    PWP_FLOAT *val)
{
    PWP_REAL locVal = 0;
    PWP_BOOL ret = val && PwModGetAttributeREAL(model, name, &locVal);
    if (ret && val) {
        *val = (PWP_FLOAT)locVal;
    }
    return ret;
}
 
 
PWP_BOOL
PwModGetAttributeBOOL(PWGM_HGRIDMODEL model, const char *name,
    PWP_BOOL *val)
{
    return PwModGetAttributeValue(model, name, PWP_VALTYPE_BOOL, val, 1);
}
 
 
PWP_BOOL
PwModGetAttributeEnum(PWGM_HGRIDMODEL model, const char *name,
    const char ** val)
{
    return PwModGetAttributeValue(model, name, PWP_VALTYPE_ENUM, val, 1);
}
 
 
#if !defined(PWGM_HIDE_UNSTRUCTURED_API)
 
 
PWP_UINT32
PwModDomainCount(PWGM_HGRIDMODEL model)
{
    return (MODEL_OUT && MODEL_OUT->PwModDomainCountCB) ?
        MODEL_OUT->PwModDomainCountCB(model) : 0;
}
 
 
PWGM_HDOMAIN
PwModEnumDomains(PWGM_HGRIDMODEL model, PWP_UINT32 ndx)
{
    return (MODEL_OUT && MODEL_OUT->PwModEnumDomainsCB) ?
        MODEL_OUT->PwModEnumDomainsCB(model, ndx) : badDomain;
}
 
 
PWGM_HVERTEX
PwModEnumVertices(PWGM_HGRIDMODEL model, PWP_UINT32 ndx)
{
    return (MODEL_OUT && MODEL_OUT->PwModEnumVerticesCB) ?
        MODEL_OUT->PwModEnumVerticesCB(model, ndx) : badVertex;
}
 
 
PWP_UINT32
PwModVertexCount(PWGM_HGRIDMODEL model)
{
    return (MODEL_OUT && MODEL_OUT->PwModVertexCountCB) ?
        MODEL_OUT->PwModVertexCountCB(model) : 0;
}
 
 
PWP_BOOL
PwModCustomIndexSchemeReady(PWGM_HGRIDMODEL model, PWGM_INDEXMAPPERCB cb,
    void *data)
{
    return (MODEL_OUT && MODEL_OUT->PwModCustomIndexSchemeReadyCB) ?
        MODEL_OUT->PwModCustomIndexSchemeReadyCB(model, cb, data) : PWP_FALSE;
}
 
PWP_BOOL
PwModStreamFaces(PWGM_HGRIDMODEL model, PWGM_ENUM_FACEORDER order,
    PWGM_BEGINSTREAMCB beginCB, PWGM_FACESTREAMCB faceCB,
    PWGM_ENDSTREAMCB endCB, void *userData)
{
    return (MODEL_OUT && MODEL_OUT->PwModStreamFacesCB) ?
        MODEL_OUT->PwModStreamFacesCB(model, order, beginCB, faceCB, endCB,
            userData) : PWP_FALSE;
}
 
 
PWP_UINT32
PwModEnumElementCount(PWGM_HGRIDMODEL model, PWGM_ELEMCOUNTS *pCounts)
{
    return (MODEL_OUT && MODEL_OUT->PwModEnumElementCountCB) ?
        MODEL_OUT->PwModEnumElementCountCB(model, pCounts) : 0;
}
 
 
PWGM_HELEMENT
PwModEnumElements(PWGM_HGRIDMODEL model, PWP_UINT32 ndx)
{
    return (MODEL_OUT && MODEL_OUT->PwModEnumElementsCB) ?
        MODEL_OUT->PwModEnumElementsCB(model, ndx) : badElement;
}
 
 
PWP_BOOL
PwModAppendEnumElementOrder(PWGM_HGRIDMODEL model, PWGM_ENUM_ELEMORDER order)
{
    return (MODEL_OUT && MODEL_OUT->PwModAppendEnumElementOrderCB) ?
        MODEL_OUT->PwModAppendEnumElementOrderCB(model, order) : 0;
}
 
 
PWP_VOID
PwModDefaultEnumElementOrder(PWGM_HGRIDMODEL model)
{
    // PWGM_ELEMTYPE_SIZE triggers core to reset the ordering
    PwModAppendEnumElementOrder(model, PWGM_ELEMORDER_SIZE);
}
 
 
PWP_UINT32
PwBlkElementCount(PWGM_HBLOCK block, PWGM_ELEMCOUNTS *pCounts)
{
    return (PWGM_HBLOCK_ISVALID(block) && BLKMODEL_OUT->PwBlkElementCountCB) ?
        BLKMODEL_OUT->PwBlkElementCountCB(block, pCounts) : 0;
}
 
 
PWGM_HELEMENT
PwBlkEnumElements(PWGM_HBLOCK block, PWP_UINT32 ndx)
{
    return (PWGM_HBLOCK_ISVALID(block) && BLKMODEL_OUT->PwBlkEnumElementsCB) ?
        BLKMODEL_OUT->PwBlkEnumElementsCB(block, ndx) : badElement;
}
 
 
PWP_UINT32
PwDomElementCount(PWGM_HDOMAIN domain, PWGM_ELEMCOUNTS *pCounts)
{
    return (PWGM_HDOMAIN_ISVALID(domain) && DOMMODEL_OUT->PwDomElementCountCB) ?
        DOMMODEL_OUT->PwDomElementCountCB(domain, pCounts) : 0;
}
 
 
PWGM_HELEMENT
PwDomEnumElements(PWGM_HDOMAIN domain, PWP_UINT32 ndx)
{
    return (PWGM_HDOMAIN_ISVALID(domain) && DOMMODEL_OUT->PwDomEnumElementsCB) ?
        DOMMODEL_OUT->PwDomEnumElementsCB(domain, ndx) : badElement;
}
 
 
PWP_BOOL
PwDomCondition(PWGM_HDOMAIN domain, PWGM_CONDDATA *pCondData)
{
    return (pCondData && PWGM_HDOMAIN_ISVALID(domain) &&
            DOMMODEL_OUT->PwDomConditionCB) ?
        DOMMODEL_OUT->PwDomConditionCB(domain, pCondData) : PWP_FALSE;
}
 
 
PWP_BOOL
PwVertDataMod(PWGM_HVERTEX vertex, PWGM_VERTDATA *pVertData)
{
    return (pVertData && PWGM_HVERTEX_ISVALID(vertex) &&
            VERTMODEL_OUT->PwVertDataModCB) ?
        VERTMODEL_OUT->PwVertDataModCB(vertex, pVertData) : PWP_FALSE;
}
 
 
PWP_BOOL
PwVertIndexMod(PWGM_HVERTEX vertex, PWP_UINT32 *pIndex)
{
    return (pIndex && PWGM_HVERTEX_ISVALID(vertex) &&
            VERTMODEL_OUT->PwVertIndexModCB) ?
        VERTMODEL_OUT->PwVertIndexModCB(vertex, pIndex) : PWP_FALSE;
}
 
 
PWP_BOOL
PwVertXyzVal(PWGM_HVERTEX vertex, PWGM_ENUM_XYZ which, PWGM_XYZVAL *pVal)
{
    return (pVal && PWGM_HVERTEX_ISVALID(vertex) &&
            VERTMODEL_OUT->PwVertXyzValCB) ?
        VERTMODEL_OUT->PwVertXyzValCB(vertex, which, pVal) : PWP_FALSE;
}
 
 
PWP_BOOL
PwElemDataMod(PWGM_HELEMENT element, PWGM_ELEMDATA *pElemData)
{
    return (pElemData && PWGM_HELEMENT_ISVALID(element) &&
            ELEMMODEL_OUT->PwElemDataModCB) ?
        ELEMMODEL_OUT->PwElemDataModCB(element, pElemData) : PWP_FALSE;
}
 
 
PWP_BOOL
PwElemDataModEnum(PWGM_HELEMENT element, PWGM_ENUMELEMDATA *pEnumElemData)
{
    return (pEnumElemData && PWGM_HELEMENT_ISVALID(element) &&
            ELEMMODEL_OUT->PwElemDataModEnumCB) ?
        ELEMMODEL_OUT->PwElemDataModEnumCB(element, pEnumElemData) : PWP_FALSE;
}
 
 
PWP_BOOL
PwElemDataCastToPoly(const PWGM_ELEMDATA *eData, PWGM_POLYELEMDATA *polyData)
{
    // polyh[]:
    //      NumUniqueIndices
    //      indices[NumUniqueIndices]
    //      NumFaces
    //      offsets[NumFaces]
    //      NumFaceIndices
    //      faceIndices[NumFaceIndices]
    const PWP_BOOL ret = (PWGM_ELEMTYPE_POLYH == eData->type);
    if (ret) {
        using PP = PWP_UINT64* const*;
        const PWP_UINT64* polyh = *(reinterpret_cast<PP>(&eData->index[0]));
        polyData->type = eData->type;
 
        polyData->vertCnt = polyh[0];
        polyData->indices = &polyh[1];
 
        polyData->numFaces = polyh[polyData->vertCnt + 1];
        polyData->offsets = &polyData->indices[polyData->vertCnt + 1];
 
        polyData->numFaceIndices = polyData->offsets[polyData->numFaces];
        polyData->faceIndices = &polyData->offsets[polyData->numFaces + 1];
    }
    return ret;
}
 
 
const char *
PwFaceOrderToText(PWGM_ENUM_FACEORDER faceOrder)
{
    const char * ret = "!Invalid";
    switch (faceOrder) {
    case PWGM_FACEORDER_DONTCARE:          ret = "DontCare"; break;
    case PWGM_FACEORDER_BOUNDARYFIRST:     ret = "BoundaryFirst"; break;
    case PWGM_FACEORDER_INTERIORFIRST:     ret = "InteriorFirst"; break;
    case PWGM_FACEORDER_BOUNDARYONLY:      ret = "BoundaryOnly"; break;
    case PWGM_FACEORDER_INTERIORONLY:      ret = "InteriorOnly"; break;
    case PWGM_FACEORDER_BCGROUPSFIRST:     ret = "BcGroupsFirst"; break;
    case PWGM_FACEORDER_BCGROUPSLAST:      ret = "BcGroupsLast"; break;
    case PWGM_FACEORDER_BCGROUPSONLY:      ret = "BcGroupsOnly"; break;
    case PWGM_FACEORDER_VCGROUPSBCLAST:    ret = "VcGroupsBcLast"; break;
    case PWGM_FACEORDER_BCGROUPSONLY_BYVC: ret = "BcGroupsOnlyByVc"; break;
    case PWGM_FACEORDER_SIZE: break; // silence compiler warning
    }
    return ret;
}
 
 
const char *
PwElemTypeToText(PWGM_ENUM_ELEMTYPE type)
{
    const char * ret = "!Invalid";
    switch (type) {
    case PWGM_ELEMTYPE_BAR:     ret = "Bar"; break;
    case PWGM_ELEMTYPE_HEX:     ret = "Hex"; break;
    case PWGM_ELEMTYPE_QUAD:    ret = "Quad"; break;
    case PWGM_ELEMTYPE_TRI:     ret = "Tri"; break;
    case PWGM_ELEMTYPE_TET:     ret = "Tet"; break;
    case PWGM_ELEMTYPE_WEDGE:   ret = "Wedge"; break;
    case PWGM_ELEMTYPE_PYRAMID: ret = "Pyramid"; break;
    case PWGM_ELEMTYPE_POINT:   ret = "Point"; break;
    case PWGM_ELEMTYPE_SIZE: // silence compiler warning
    default: break;
    }
    return ret;
}
 
#endif // !defined(PWGM_HIDE_UNSTRUCTURED_API)
 
 
 
//***************************************************************************
//***************************************************************************
//***************************************************************************
//***************************************************************************
 
#if !defined(PWGM_HIDE_STRUCTURED_API)
 
 
PWP_UINT32
PwModBoundaryCount(PWGM_HGRIDMODEL model)
{
    return (MODEL_OUT && MODEL_OUT->PwModBoundaryCountCB) ?
        MODEL_OUT->PwModBoundaryCountCB(model) : 0;
}
 
 
PWGM_HBNDRY
PwModEnumBoundaries(PWGM_HGRIDMODEL model, PWP_UINT32 ndx)
{
    return (MODEL_OUT && MODEL_OUT->PwModEnumBoundariesCB) ?
        MODEL_OUT->PwModEnumBoundariesCB(model, ndx) : badBoundary;
}
 
 
PWP_UINT32
PwModConnectionCount(PWGM_HGRIDMODEL model)
{
    return (MODEL_OUT && MODEL_OUT->PwModConnectionCountCB) ?
        MODEL_OUT->PwModConnectionCountCB(model) : 0;
}
 
 
PWGM_HCNXN
PwModEnumConnections(PWGM_HGRIDMODEL model, PWP_UINT32 ndx)
{
    return (MODEL_OUT && MODEL_OUT->PwModEnumConnectionsCB) ?
        MODEL_OUT->PwModEnumConnectionsCB(model, ndx) : badConnection;
}
 
 
PWP_BOOL
PwModNdxBoundary(PWGM_HGRIDMODEL model, PWP_UINT32 ndx,
    PWGM_BNDRYDATA *pBndryData)
{
    return (MODEL_OUT && MODEL_OUT->PwModNdxBoundaryCB) ?
            MODEL_OUT->PwModNdxBoundaryCB(model, ndx, pBndryData) :
            PWP_FALSE;
}
 
 
PWP_BOOL
PwModNdxBoundaryAndCondition(PWGM_HGRIDMODEL model, PWP_UINT32 ndx,
    PWGM_BNDRYDATA *pBndryData, PWGM_CONDDATA *pCondData)
{
    return (MODEL_OUT && MODEL_OUT->PwModNdxBoundaryAndConditionCB &&
            (pBndryData || pCondData)) ?
        MODEL_OUT->PwModNdxBoundaryAndConditionCB(model, ndx, pBndryData,
            pCondData) : PWP_FALSE;
}
 
 
PWP_BOOL
PwModNdxConnection(PWGM_HGRIDMODEL model, PWP_UINT32 ndx,
    PWGM_CNXNDATA *pCnxnData)
{
    return (MODEL_OUT && MODEL_OUT->PwModNdxConnectionCB && pCnxnData) ?
        MODEL_OUT->PwModNdxConnectionCB(model, ndx, pCnxnData) : PWP_FALSE;
}
 
 
PWP_BOOL
PwBlkSize(PWGM_HBLOCK block, PWGM_STR_SIZE *pSize)
{
    return (BLKMODEL_OUT && BLKMODEL_OUT->PwBlkSizeCB) ?
        BLKMODEL_OUT->PwBlkSizeCB(block, pSize) : PWP_FALSE;
}
 
 
PWP_BOOL
PwBlkNdxVertData(PWGM_HBLOCK block, PWGM_INDEX3 ndx3, PWGM_VERTDATA *pVertData)
{
    return (BLKMODEL_OUT && BLKMODEL_OUT->PwBlkNdxVertDataCB) ?
        BLKMODEL_OUT->PwBlkNdxVertDataCB(block, ndx3, pVertData) : PWP_FALSE;
}
 
 
PWP_BOOL
PwModCustomIndex3SchemeReady(PWGM_HGRIDMODEL model, PWGM_INDEX3MAPPERCB cb,
    void *data)
{
    return (MODEL_OUT && MODEL_OUT->PwModCustomIndex3SchemeReadyCB) ?
        MODEL_OUT->PwModCustomIndex3SchemeReadyCB(model, cb, data) : PWP_FALSE;
}
 
 
PWP_UINT32
PwBlkBoundaryCount(PWGM_HBLOCK block)
{
    return (BLKMODEL_OUT && BLKMODEL_OUT->PwBlkBoundaryCountCB) ?
        BLKMODEL_OUT->PwBlkBoundaryCountCB(block) : 0;
}
 
 
PWGM_HBNDRY
PwBlkEnumBoundaries(PWGM_HBLOCK block, PWP_UINT32 ndx)
{
    return (BLKMODEL_OUT && BLKMODEL_OUT->PwBlkEnumBoundariesCB) ?
        BLKMODEL_OUT->PwBlkEnumBoundariesCB(block, ndx) : badBoundary;
}
 
 
PWP_UINT32
PwBlkConnectionCount(PWGM_HBLOCK block)
{
    return (BLKMODEL_OUT && BLKMODEL_OUT->PwBlkConnectionCountCB) ?
        BLKMODEL_OUT->PwBlkConnectionCountCB(block) : 0;
}
 
 
PWGM_HCNXN
PwBlkEnumConnections(PWGM_HBLOCK block, PWP_UINT32 ndx)
{
    return (BLKMODEL_OUT && BLKMODEL_OUT->PwBlkEnumConnectionsCB) ?
        BLKMODEL_OUT->PwBlkEnumConnectionsCB(block, ndx) : badConnection;
}
 
 
PWP_BOOL
PwBlkNdxBoundary(PWGM_HBLOCK block, PWP_UINT32 ndx, PWGM_BNDRYDATA *pBndryData)
{
    return (BLKMODEL_OUT && BLKMODEL_OUT->PwBlkNdxBoundaryCB && pBndryData) ?
        BLKMODEL_OUT->PwBlkNdxBoundaryCB(block, ndx, pBndryData) : PWP_FALSE;
}
 
 
PWP_BOOL
PwBlkNdxBoundaryAndCondition(PWGM_HBLOCK block, PWP_UINT32 ndx,
    PWGM_BNDRYDATA *pBndryData, PWGM_CONDDATA *pCondData)
{
    return (BLKMODEL_OUT && BLKMODEL_OUT->PwBlkNdxBoundaryAndConditionCB &&
            (pBndryData || pCondData)) ?
        BLKMODEL_OUT->PwBlkNdxBoundaryAndConditionCB(block, ndx, pBndryData,
            pCondData) : PWP_FALSE;
}
 
 
PWP_BOOL
PwBlkNdxConnection(PWGM_HBLOCK block, PWP_UINT32 ndx, PWGM_CNXNDATA *pCnxnData)
{
    return (BLKMODEL_OUT && BLKMODEL_OUT->PwBlkNdxConnectionCB && pCnxnData) ?
        BLKMODEL_OUT->PwBlkNdxConnectionCB(block, ndx, pCnxnData) : PWP_FALSE;
}
 
 
PWP_BOOL
PwBoundary(PWGM_HBNDRY boundary, PWGM_BNDRYDATA *pBndryData)
{
    return (BNDRYMODEL_OUT && BNDRYMODEL_OUT->PwBoundaryCB && pBndryData) ?
        BNDRYMODEL_OUT->PwBoundaryCB(boundary, pBndryData) : PWP_FALSE;
}
 
 
PWP_BOOL
PwBndryCondition(PWGM_HBNDRY boundary, PWGM_CONDDATA *pCondData)
{
    return (BNDRYMODEL_OUT && BNDRYMODEL_OUT->PwBndryConditionCB) ?
        BNDRYMODEL_OUT->PwBndryConditionCB(boundary, pCondData) : PWP_FALSE;
}
 
 
PWP_BOOL
PwConnection(PWGM_HCNXN connection, PWGM_CNXNDATA *pCnxnData)
{
    return (CNXNMODEL_OUT && CNXNMODEL_OUT->PwConnectionCB && pCnxnData) ?
        CNXNMODEL_OUT->PwConnectionCB(connection, pCnxnData) : PWP_FALSE;
}
 
 
PWP_BOOL
PwXform2to3(const PWGM_INDEX_XFORM2 *pX2, PWGM_INDEX_XFORM *pX3)
{
    // XFORM2       XFORM
    // ------       -------
    // A B C        A B 0 C
    // D E F   ==>  D E 0 F
    //              0 0 1 0
    PWP_BOOL ret = (pX2 && pX3) ? PWP_TRUE : PWP_FALSE;
    if (ret) {
        // row 0
        pX3->m[0][0] = pX2->m[0][0];
        pX3->m[0][1] = pX2->m[0][1];
        pX3->m[0][2] = 0;
        pX3->m[0][0] = pX2->m[0][2];
        // row 1
        pX3->m[1][0] = pX2->m[1][0];
        pX3->m[1][1] = pX2->m[1][1];
        pX3->m[1][2] = 0;
        pX3->m[1][0] = pX2->m[1][2];
        // row 2
        pX3->m[2][0] = 0;
        pX3->m[2][1] = 0;
        pX3->m[2][2] = 1;
        pX3->m[2][0] = 0;
    }
    return ret;
}
 
 
PWP_BOOL
PwXform3to2(const PWGM_INDEX_XFORM *pX3, PWGM_INDEX_XFORM2 *pX2)
{
    // XFORM         XFORM2
    // -------       ------
    // A B C D       A B D
    // E F G H  ==>  E F H
    // I J K L       
    PWP_BOOL ret = (pX2 && pX3) ? PWP_TRUE : PWP_FALSE;
    if (ret) {
        // row 0
        pX2->m[0][0] = pX3->m[0][0];
        pX2->m[0][1] = pX3->m[0][1];
        pX2->m[0][2] = pX3->m[0][3];
        // row 1
        pX2->m[1][0] = pX3->m[1][0];
        pX2->m[1][1] = pX3->m[1][1];
        pX2->m[1][2] = pX3->m[1][3];
    }
    return ret;
}
 
 
PWGM_INDEX3
PwXformApply(const PWGM_INDEX_XFORM *pX3, PWGM_INDEX3 ijk)
{
    PWGM_INDEX3 ret;
    ret.i = pX3->m[0][0] * ijk.i + pX3->m[0][1] * ijk.j + pX3->m[0][2] * ijk.k
                + pX3->m[0][3];
    ret.j = pX3->m[1][0] * ijk.i + pX3->m[1][1] * ijk.j + pX3->m[1][2] * ijk.k
                + pX3->m[1][3];
    ret.k = pX3->m[2][0] * ijk.i + pX3->m[2][1] * ijk.j + pX3->m[2][2] * ijk.k
                + pX3->m[2][3];
    return ret;
}
 
 
PWGM_ENUM_IJK
PwXformFollows(const PWGM_INDEX_XFORM *pX3, PWGM_ENUM_IJK localAxis,
    PWP_BOOL *pFlipped)
{
    PWGM_ENUM_IJK transformedAxis = PWGM_IJK_SIZE; /* invalid */
    PWGM_INDEX3 ijk = { 0, 0, 0 };
    PWGM_INDEX3 ijk2 = { 0, 0, 0 };
    if (pFlipped) {
        *pFlipped = PWP_FALSE;
    }
    /* construct axis vec for localAxis that will be rotated below */
    switch (localAxis) {
    case PWGM_IJK_I: ijk.i = 1; break;
    case PWGM_IJK_J: ijk.j = 1; break;
    case PWGM_IJK_K: ijk.k = 1; break;
    case PWGM_IJK_SIZE: break; // silence compiler warning
    }
    /* apply rotation only */
    ijk2.i = pX3->m[0][0] * ijk.i + pX3->m[0][1] * ijk.j + pX3->m[0][2] * ijk.k;
    ijk2.j = pX3->m[1][0] * ijk.i + pX3->m[1][1] * ijk.j + pX3->m[1][2] * ijk.k;
    ijk2.k = pX3->m[2][0] * ijk.i + pX3->m[2][1] * ijk.j + pX3->m[2][2] * ijk.k;
    /* determine which axis it is in the transformed coord system */
    if ((0 != ijk2.i) && (0 == ijk2.j) && (0 == ijk2.k)) {
        transformedAxis = PWGM_IJK_I;
        if (pFlipped) {
            *pFlipped = ((1 == ijk2.i) ? PWP_FALSE : PWP_TRUE);
        }
    }
    else if ((0 != ijk2.j) && (0 == ijk2.i) && (0 == ijk2.k)) {
        transformedAxis = PWGM_IJK_J;
        if (pFlipped) {
            *pFlipped = ((1 == ijk2.j) ? PWP_FALSE : PWP_TRUE);
        }
    }
    else if ((0 != ijk2.k) && (0 == ijk2.i) && (0 == ijk2.j)) {
        transformedAxis = PWGM_IJK_K;
        if (pFlipped) {
            *pFlipped = ((1 == ijk2.k) ? PWP_FALSE : PWP_TRUE);
        }
    }
    return transformedAxis;
}
 
 
PWGM_INDEX3
PwXform2Apply(const PWGM_INDEX_XFORM2 *pX2, PWGM_INDEX3 ijk)
{
    PWGM_INDEX3 ret;
    ret.i = pX2->m[0][0] * ijk.i + pX2->m[0][1] * ijk.j + pX2->m[0][2];
    ret.j = pX2->m[1][0] * ijk.i + pX2->m[1][1] * ijk.j + pX2->m[1][2];
    ret.k = ijk.k;
    return ret;
}
 
 
PWGM_ENUM_IJK
PwXform2Follows(const PWGM_INDEX_XFORM2 *pX2, PWGM_ENUM_IJK localAxis,
    PWP_BOOL *pFlipped)
{
    PWGM_ENUM_IJK ret = PWGM_IJK_SIZE;
    PWGM_INDEX_XFORM x3;
    if (PwXform2to3(pX2, &x3)) {
        ret = PwXformFollows(&x3, localAxis, pFlipped);
    }
    return ret;
}
 
 
PWP_BOOL
PwInRange(PWGM_INDEX3 ijk, const PWGM_STR_RANGE *pRange)
{
    return (ijk.i >= pRange->beg.i) && (ijk.i <= pRange->end.i) &&
           (ijk.j >= pRange->beg.j) && (ijk.j <= pRange->end.j) &&
           (ijk.k >= pRange->beg.k) && (ijk.k <= pRange->end.k);
}
 
#endif // !defined(PWGM_HIDE_STRUCTURED_API)
 
 
 
//***************************************************************************
//***************************************************************************
//***************************************************************************
//***************************************************************************
 
#if !defined(PWGM_HIDE_IMPORT_API)
 
PWGM_HCONNECTOR
PwModCreateCon(PWGM_HGRIDMODEL model, PWP_UINT size)
{
    return (MODEL_IN && MODEL_IN->PwModCreateConCB) ?
        MODEL_IN->PwModCreateConCB(model, size) : badConnector;
}
 
 
PWGM_HVERTEXLIST
PwBlkGetVertexList(PWGM_HBLOCK block)
{
    return (BLKMODEL_IN && BLKMODEL_IN->PwBlkGetVertexListCB) ?
        BLKMODEL_IN->PwBlkGetVertexListCB(block) : badVertexList;
}
 
 
PWGM_HVERTEXLIST
PwDomGetVertexList(PWGM_HDOMAIN domain)
{
    return (DOMMODEL_IN && DOMMODEL_IN->PwDomGetVertexListCB) ?
        DOMMODEL_IN->PwDomGetVertexListCB(domain) : badVertexList;
}
 
 
PWGM_HVERTEXLIST
PwConGetVertexList(PWGM_HCONNECTOR connector)
{
    return (CONMODEL_IN && CONMODEL_IN->PwConGetVertexListCB) ?
        CONMODEL_IN->PwConGetVertexListCB(connector) : badVertexList;
}
 
 
PWP_BOOL
PwConSetName(PWGM_HCONNECTOR connector, const char *name)
{
    return (CONMODEL_IN && CONMODEL_IN->PwConSetNameCB) ?
        CONMODEL_IN->PwConSetNameCB(connector, name) : PWP_FALSE;
}
 
 
PWP_BOOL
PwBlkSetName(PWGM_HBLOCK block, const char *name)
{
    return (BLKMODEL_IN && BLKMODEL_IN->PwBlkSetNameCB) ?
        BLKMODEL_IN->PwBlkSetNameCB(block, name) : PWP_FALSE;
}
 
 
PWP_BOOL
PwDomSetName(PWGM_HDOMAIN domain, const char *name)
{
    return (DOMMODEL_IN && DOMMODEL_IN->PwDomSetNameCB) ?
        DOMMODEL_IN->PwDomSetNameCB(domain, name) : PWP_FALSE;
}
 
 
PWP_BOOL
PwVlstIsUnstructured(PWGM_HVERTEXLIST vertlist)
{
    return (VLISTMODEL_IN && VLISTMODEL_IN->PwVlstIsUnstructuredCB) ?
        VLISTMODEL_IN->PwVlstIsUnstructuredCB(vertlist) : PWP_FALSE;
}
 
 
PWP_BOOL
PwVlstIsStructured(PWGM_HVERTEXLIST vertlist)
{
    return (VLISTMODEL_IN && VLISTMODEL_IN->PwVlstIsUnstructuredCB) ?
        !VLISTMODEL_IN->PwVlstIsUnstructuredCB(vertlist) : PWP_FALSE;
}
 
 
PWP_UINT
PwVlstGetIndexDimensionality(PWGM_HVERTEXLIST vertlist)
{
    return (VLISTMODEL_IN && VLISTMODEL_IN->PwVlstGetIndexDimensionalityCB) ?
        VLISTMODEL_IN->PwVlstGetIndexDimensionalityCB(vertlist) : 0;
}
 
 
PWP_ENUM_DIMENSION
PwVlstGetBlkElemDimensionality(PWGM_HVERTEXLIST vertlist)
{
    return (VLISTMODEL_IN && VLISTMODEL_IN->PwVlstGetBlkElemDimensionalityCB) ?
        VLISTMODEL_IN->PwVlstGetBlkElemDimensionalityCB(vertlist) :
        PWP_DIMENSION_SIZE;
}
 
 
PWP_BOOL
PwVlstSetXYZVal(PWGM_HVERTEXLIST vertlist, const PWP_UINT ndx,
    const PWGM_ENUM_XYZ which, const PWGM_XYZVAL val)
{
    const PWGM_INDEX3 ndx3 = { PWP_INT32(ndx), 0, 0 };
    return (VLISTMODEL_IN && VLISTMODEL_IN->PwVlstSetXYZVal3CB) ?
        VLISTMODEL_IN->PwVlstSetXYZVal3CB(vertlist, ndx3, which, val) :
        PWP_FALSE;
}
 
 
PWP_BOOL
PwVlstSetXYZ(PWGM_HVERTEXLIST vertlist, const PWP_UINT ndx, const PWGM_XYZVAL x,
    const PWGM_XYZVAL y, const PWGM_XYZVAL z)
{
    const PWGM_INDEX3 ndx3 = { PWP_INT32(ndx), 0, 0 };
    return (VLISTMODEL_IN && VLISTMODEL_IN->PwVlstSetXYZ3CB) ?
        VLISTMODEL_IN->PwVlstSetXYZ3CB(vertlist, ndx3, x, y, z) : PWP_FALSE;
}
 
 
PWP_BOOL
PwVlstSetXYZData(PWGM_HVERTEXLIST vertlist, const PWP_UINT ndx,
    const PWGM_VERTDATA &v)
{
    const PWGM_INDEX3 ndx3 = { PWP_INT32(ndx), 0, 0 };
    return (VLISTMODEL_IN && VLISTMODEL_IN->PwVlstSetXYZ3CB) ?
        VLISTMODEL_IN->PwVlstSetXYZ3CB(vertlist, ndx3, v.x, v.y, v.z) :
        PWP_FALSE;
}
 
 
PWP_BOOL
PwVlstSetXYZVal2(PWGM_HVERTEXLIST vertlist, const PWGM_INDEX2 ndx2,
    const PWGM_ENUM_XYZ which, const PWGM_XYZVAL val)
{
    const PWGM_INDEX3 ndx3 = { ndx2.i, ndx2.j, 0 };
    return (VLISTMODEL_IN && VLISTMODEL_IN->PwVlstSetXYZVal3CB) ?
        VLISTMODEL_IN->PwVlstSetXYZVal3CB(vertlist, ndx3, which, val) :
        PWP_FALSE;
}
 
 
PWP_BOOL
PwVlstSetXYZ2(PWGM_HVERTEXLIST vertlist, const PWGM_INDEX2 ndx2,
    const PWGM_XYZVAL x, const PWGM_XYZVAL y, const PWGM_XYZVAL z)
{
    const PWGM_INDEX3 ndx3 = { ndx2.i, ndx2.j, 0 };
    return (VLISTMODEL_IN && VLISTMODEL_IN->PwVlstSetXYZ3CB) ?
        VLISTMODEL_IN->PwVlstSetXYZ3CB(vertlist, ndx3, x, y, z) : PWP_FALSE;
}
 
 
PWP_BOOL
PwVlstSetXYZ2Data(PWGM_HVERTEXLIST vertlist, const PWGM_INDEX2 ndx2,
    const PWGM_VERTDATA &v)
{
    const PWGM_INDEX3 ndx3 = { ndx2.i, ndx2.j, 0 };
    return (VLISTMODEL_IN && VLISTMODEL_IN->PwVlstSetXYZ3CB) ?
        VLISTMODEL_IN->PwVlstSetXYZ3CB(vertlist, ndx3, v.x, v.y, v.z) :
        PWP_FALSE;
}
 
 
PWP_BOOL
PwVlstSetXYZVal3(PWGM_HVERTEXLIST vertlist, const PWGM_INDEX3 ndx3,
    const PWGM_ENUM_XYZ which, const PWGM_XYZVAL val)
{
    return (VLISTMODEL_IN && VLISTMODEL_IN->PwVlstSetXYZVal3CB) ?
        VLISTMODEL_IN->PwVlstSetXYZVal3CB(vertlist, ndx3, which, val) :
        PWP_FALSE;
}
 
 
PWP_BOOL
PwVlstSetXYZ3(PWGM_HVERTEXLIST vertlist, const PWGM_INDEX3 ndx3,
    const PWGM_XYZVAL x, const PWGM_XYZVAL y, const PWGM_XYZVAL z)
{
    return (VLISTMODEL_IN && VLISTMODEL_IN->PwVlstSetXYZ3CB) ?
        VLISTMODEL_IN->PwVlstSetXYZ3CB(vertlist, ndx3, x, y, z) : PWP_FALSE;
}
 
 
PWP_BOOL
PwVlstSetXYZ3Data(PWGM_HVERTEXLIST vertlist, const PWGM_INDEX3 ndx3,
    const PWGM_VERTDATA &v)
{
    return (VLISTMODEL_IN && VLISTMODEL_IN->PwVlstSetXYZ3CB) ?
        VLISTMODEL_IN->PwVlstSetXYZ3CB(vertlist, ndx3, v.x, v.y, v.z) :
        PWP_FALSE;
}
 
 
PWP_BOOL
PwBlkSetProperty(PWGM_HBLOCK block, const char *key, const char *val)
{
    return (BLKMODEL_IN && BLKMODEL_IN->PwBlkSetPropertyCB) ?
        BLKMODEL_IN->PwBlkSetPropertyCB(block, key, val) : PWP_FALSE;
}
 
 
PWP_BOOL
PwDomSetProperty(PWGM_HDOMAIN domain, const char *key, const char *val)
{
    return (DOMMODEL_IN && DOMMODEL_IN->PwDomSetPropertyCB) ?
        DOMMODEL_IN->PwDomSetPropertyCB(domain, key, val) : PWP_FALSE;
}
 
 
PWP_BOOL
PwConSetProperty(PWGM_HCONNECTOR connector, const char *key, const char *val)
{
    return (CONMODEL_IN && CONMODEL_IN->PwConSetPropertyCB) ?
        CONMODEL_IN->PwConSetPropertyCB(connector, key, val) : PWP_FALSE;
}
 
 
PWP_BOOL
PwAsmSetProperty(PWGM_HBLOCKASSEMBLER blkAsm, const PWP_UINT32 propertySetId,
    const char *key, const char *val)
{
    return (BLKASMMODEL_IN && BLKASMMODEL_IN->PwAsmSetPropertyCB) ?
        BLKASMMODEL_IN->PwAsmSetPropertyCB(blkAsm, propertySetId, key, val) :
        PWP_FALSE;
}
 
 
PWP_BOOL
PwBlkSetConditionUserName(PWGM_HBLOCK block, const char *userName)
{
    return PwBlkSetProperty(block, PropUserName, userName);
}
 
 
PWP_BOOL
PwBlkSetConditionUserId(PWGM_HBLOCK block, const PWP_UINT32 userId)
{
    std::ostringstream oss;
    oss << userId;
    return PwBlkSetProperty(block, PropUserId, oss.str().c_str());
}
 
 
PWP_BOOL
PwBlkSetConditionTypeName(PWGM_HBLOCK block, const char *typeName)
{
    return PwBlkSetProperty(block, PropTypeName, typeName);
}
 
 
PWP_BOOL
PwBlkSetConditionTypeId(PWGM_HBLOCK block, const PWP_UINT32 typeId)
{
    std::ostringstream oss;
    oss << typeId;
    return PwBlkSetProperty(block, PropTypeId, oss.str().c_str());
}
 
 
PWP_BOOL
PwBlkSetCondition(PWGM_HBLOCK block, const PWGM_CONDDATA &condData)
{
    const bool ret = PwBlkSetConditionUserName(block, condData.name) &&
        PwBlkSetConditionUserId(block, condData.id) &&
        PwBlkSetConditionTypeName(block, condData.type) &&
        PwBlkSetConditionTypeId(block, condData.tid);
    return PWP_CAST_BOOL(ret);
}
 
 
PWP_BOOL
PwDomSetConditionUserName(PWGM_HDOMAIN domain, const char *userName)
{
    return PwDomSetProperty(domain, PropUserName, userName);
}
 
 
PWP_BOOL
PwDomSetConditionUserId(PWGM_HDOMAIN domain, const PWP_UINT32 userId)
{
    std::ostringstream oss;
    oss << userId;
    return PwDomSetProperty(domain, PropUserId, oss.str().c_str());
}
 
 
PWP_BOOL
PwDomSetConditionTypeName(PWGM_HDOMAIN domain, const char *typeName)
{
    return PwDomSetProperty(domain, PropTypeName, typeName);
}
 
 
PWP_BOOL
PwDomSetConditionTypeId(PWGM_HDOMAIN domain, const PWP_UINT32 typeId)
{
    std::ostringstream oss;
    oss << typeId;
    return PwDomSetProperty(domain, PropTypeId, oss.str().c_str());
}
 
 
PWP_BOOL
PwDomSetCondition(PWGM_HDOMAIN domain, const PWGM_CONDDATA &condData)
{
    const bool ret = PwDomSetConditionUserName(domain, condData.name) &&
        PwDomSetConditionUserId(domain, condData.id) &&
        PwDomSetConditionTypeName(domain, condData.type) &&
        PwDomSetConditionTypeId(domain, condData.tid);
    return PWP_CAST_BOOL(ret);
}
 
 
PWP_BOOL
PwConSetConditionUserName(PWGM_HCONNECTOR connector, const char *userName)
{
    return PwConSetProperty(connector, PropUserName, userName);
}
 
 
PWP_BOOL
PwConSetConditionUserId(PWGM_HCONNECTOR connector, const PWP_UINT32 userId)
{
    std::ostringstream oss;
    oss << userId;
    return PwConSetProperty(connector, PropUserId, oss.str().c_str());
}
 
 
PWP_BOOL
PwConSetConditionTypeName(PWGM_HCONNECTOR connector, const char *typeName)
{
    return PwConSetProperty(connector, PropTypeName, typeName);
}
 
 
PWP_BOOL
PwConSetConditionTypeId(PWGM_HCONNECTOR connector, const PWP_UINT32 typeId)
{
    std::ostringstream oss;
    oss << typeId;
    return PwConSetProperty(connector, PropTypeId, oss.str().c_str());
}
 
 
PWP_BOOL
PwConSetCondition(PWGM_HCONNECTOR connector, const PWGM_CONDDATA &condData)
{
    const bool ret = PwConSetConditionUserName(connector, condData.name) &&
        PwConSetConditionUserId(connector, condData.id) &&
        PwConSetConditionTypeName(connector, condData.type) &&
        PwConSetConditionTypeId(connector, condData.tid);
    return PWP_CAST_BOOL(ret);
}
 
 
PWP_BOOL
PwAsmSetConditionUserName(PWGM_HBLOCKASSEMBLER h, const PWGM_CONDKEY key,
    const char *userName)
{
    return PwAsmSetProperty(h, (PWP_UINT32)key, PropUserName, userName);
}
 
 
PWP_BOOL
PwAsmSetConditionUserId(PWGM_HBLOCKASSEMBLER h, const PWGM_CONDKEY key,
    const PWP_UINT32 userId)
{
    std::ostringstream oss;
    oss << userId;
    return PwAsmSetProperty(h, (PWP_UINT32)key, PropUserId, oss.str().c_str());
}
 
 
PWP_BOOL
PwAsmSetConditionTypeName(PWGM_HBLOCKASSEMBLER h, const PWGM_CONDKEY key,
    const char *typeName)
{
    return PwAsmSetProperty(h, (PWP_UINT32)key, PropTypeName, typeName);
}
 
 
PWP_BOOL
PwAsmSetConditionTypeId(PWGM_HBLOCKASSEMBLER h, const PWGM_CONDKEY key,
    const PWP_UINT32 typeId)
{
    std::ostringstream oss;
    oss << typeId;
    return PwAsmSetProperty(h, (PWP_UINT32)key, PropTypeId, oss.str().c_str());
}
 
 
PWP_BOOL
PwAsmSetCondition(PWGM_HBLOCKASSEMBLER h, const PWGM_CONDKEY key,
    const PWGM_CONDDATA &condData)
{
    const bool ret = PwAsmSetConditionUserName(h, key, condData.name) &&
        PwAsmSetConditionUserId(h, key, condData.id) &&
        PwAsmSetConditionTypeName(h, key, condData.type) &&
        PwAsmSetConditionTypeId(h, key, condData.tid);
    return PWP_CAST_BOOL(ret);
}
 
 
PWP_BOOL
PwAsmSetCellSpanConditionKey(PWGM_HBLOCKASSEMBLER blkAsm,
    const PWGM_CONDKEY key, const PWP_UINT32 startCell,
    const PWP_UINT32 endCell)
{
    return (BLKASMMODEL_IN && BLKASMMODEL_IN->PwAsmSetCellSpanConditionKeyCB) ?
        BLKASMMODEL_IN->PwAsmSetCellSpanConditionKeyCB(blkAsm, key, startCell, endCell) :
        PWP_FALSE;
}
 
 
PWP_BOOL
PwAsmSetCellConditionKey(PWGM_HBLOCKASSEMBLER assembler, const PWGM_CONDKEY key,
    const PWP_UINT32 cell)
{
    return PwAsmSetCellSpanConditionKey(assembler, key, cell, cell);
}
 
 
PWP_BOOL
PwVlstReadFile(PWGM_HVERTEXLIST vertlist, FILE *file,
    const PWGM_XYZ_CLUSTERING fileClustering,
    const PWP_ENDIANNESS fileByteOrder, const PWP_ENUM_PRECISION filePrecision)
{
    return (VLISTMODEL_IN && VLISTMODEL_IN->PwVlstReadFileCB) ?
        VLISTMODEL_IN->PwVlstReadFileCB(vertlist, file, fileClustering,
            fileByteOrder, filePrecision) : PWP_FALSE;
}
 
 
PWGM_HVERTEXLIST
PwModCreateUnsVertexList(PWGM_HGRIDMODEL model,
    const PWP_ENUM_DIMENSION blkElemDimty)
{
    return (MODEL_IN && MODEL_IN->PwModCreateUnsVertexListCB) ?
        MODEL_IN->PwModCreateUnsVertexListCB(model, blkElemDimty) :
            badVertexList;
}
 
 
PWGM_HVERTEXLIST
PwModCreateUnsVertexList3(PWGM_HGRIDMODEL model)
{
    return PwModCreateUnsVertexList(model, PWP_DIMENSION_3D);
}
 
 
PWGM_HVERTEXLIST
PwModCreateUnsVertexList2(PWGM_HGRIDMODEL model)
{
    return PwModCreateUnsVertexList(model, PWP_DIMENSION_2D);
}
 
 
PWP_BOOL
PwVlstAllocate(PWGM_HVERTEXLIST vertlist, const PWP_UINT n)
{
    return VLISTMODEL_IN && VLISTMODEL_IN->PwVlstAllocateCB &&
        VLISTMODEL_IN->PwVlstAllocateCB(vertlist, n);
}
 
 
PWGM_HBLOCK
PwVlstCreateUnsBlock(PWGM_HVERTEXLIST vertlist)
{
    return (VLISTMODEL_IN && VLISTMODEL_IN->PwVlstCreateUnsBlockCB) ?
        VLISTMODEL_IN->PwVlstCreateUnsBlockCB(vertlist) : badBlock;
}
 
 
PWP_BOOL
PwUnsBlkAllocateElements(PWGM_HBLOCK block, const PWGM_ENUM_ELEMTYPE cellType,
    const PWP_UINT count)
{
    return (BLKMODEL_IN && BLKMODEL_IN->PwUnsBlkAllocateElementsCB) ?
        BLKMODEL_IN->PwUnsBlkAllocateElementsCB(block, cellType, count) :
        PWP_FALSE;
}
 
 
PWP_BOOL
PwUnsBlkAllocateElementCounts(PWGM_HBLOCK block, const PWGM_ELEMCOUNTS &counts)
{
    if (PWP_DIMENSION_3D == PwVlstGetBlkElemDimensionality(
            PwBlkGetVertexList(block))) {
        // only assign 3-D block element counts
        return PwUnsBlkAllocateElements(block, PWGM_ELEMTYPE_HEX,
                PWGM_ECNT_Hex(counts)) &&
            PwUnsBlkAllocateElements(block, PWGM_ELEMTYPE_PYRAMID,
                PWGM_ECNT_Pyramid(counts)) &&
            PwUnsBlkAllocateElements(block, PWGM_ELEMTYPE_TET,
                PWGM_ECNT_Tet(counts)) &&
            PwUnsBlkAllocateElements(block, PWGM_ELEMTYPE_WEDGE,
                PWGM_ECNT_Wedge(counts));
    }
    // only assign 2-D block element counts
    return PwUnsBlkAllocateElements(block, PWGM_ELEMTYPE_QUAD,
            PWGM_ECNT_Quad(counts)) &&
        PwUnsBlkAllocateElements(block, PWGM_ELEMTYPE_TRI,
            PWGM_ECNT_Tri(counts));
}
 
 
PWP_BOOL
PwUnsBlkSetElement(PWGM_HBLOCK block, const PWP_UINT ndx,
    const PWGM_ELEMDATA *eData)
{
    return (BLKMODEL_IN && BLKMODEL_IN->PwUnsBlkSetElementCB) ?
        BLKMODEL_IN->PwUnsBlkSetElementCB(block, ndx, eData) : PWP_FALSE;
}
 
 
PWGM_HDOMAIN
PwVlstCreateUnsDomain(PWGM_HVERTEXLIST vertlist)
{
    return (VLISTMODEL_IN && VLISTMODEL_IN->PwVlstCreateUnsDomainCB) ?
        VLISTMODEL_IN->PwVlstCreateUnsDomainCB(vertlist) : badDomain;
}
 
 
PWGM_HDOMAIN
PwVlstCreateUnsBoundary(PWGM_HVERTEXLIST vertlist)
{
    PWGM_HDOMAIN hDom = PwVlstCreateUnsDomain(vertlist);
    if (!PwDomSetProperty(hDom, PropSubType, SubTypeBoundary)) {
        // not good
        hDom = PWGM_HDOMAIN_INIT;
    }
    return hDom;
}
 
 
PWP_BOOL
PwUnsDomAllocateElements(PWGM_HDOMAIN domain, const PWGM_ENUM_ELEMTYPE cellType,
    const PWP_UINT n)
{
    return (DOMMODEL_IN && DOMMODEL_IN->PwUnsDomAllocateElementsCB) ?
        DOMMODEL_IN->PwUnsDomAllocateElementsCB(domain, cellType, n): PWP_FALSE;
}
 
 
PWP_BOOL
PwUnsDomAllocateElementCounts(PWGM_HDOMAIN domain, const PWGM_ELEMCOUNTS &counts)
{
    return PwUnsDomAllocateElements(domain, PWGM_ELEMTYPE_TRI,
            PWGM_ECNT_Tri(counts)) &&
        PwUnsDomAllocateElements(domain, PWGM_ELEMTYPE_QUAD,
            PWGM_ECNT_Quad(counts));
}
 
 
PWP_BOOL
PwUnsDomSetElement(PWGM_HDOMAIN domain, const PWP_UINT ndx,
    const PWGM_ELEMDATA *eData)
{
    return (DOMMODEL_IN && DOMMODEL_IN->PwUnsDomSetElementCB) ?
        DOMMODEL_IN->PwUnsDomSetElementCB(domain, ndx, eData) : PWP_FALSE;
}
 
 
PWGM_HBLOCKASSEMBLER
PwVlstCreateBlockAssembler(PWGM_HVERTEXLIST vertlist)
{
    return (VLISTMODEL_IN && VLISTMODEL_IN->PwVlstCreateBlockAssemblerCB) ?
        VLISTMODEL_IN->PwVlstCreateBlockAssemblerCB(vertlist) : badAssembler;
}
 
 
PWP_BOOL
PwAsmPushElementFace(PWGM_HBLOCKASSEMBLER blkAsm,
    const PWGM_ASSEMBLER_DATA *face)
{
    return (BLKASMMODEL_IN && BLKASMMODEL_IN->PwAsmPushElementFaceCB) ?
        BLKASMMODEL_IN->PwAsmPushElementFaceCB(blkAsm, face) : PWP_FALSE;
}
 
 
PWP_BOOL
PwAsmFinalize(PWGM_HBLOCKASSEMBLER blkAsm)
{
    return (BLKASMMODEL_IN && BLKASMMODEL_IN->PwAsmFinalizeCB) ?
        BLKASMMODEL_IN->PwAsmFinalizeCB(blkAsm) : PWP_FALSE;
}
 
 
PWGM_HVERTEXLIST
PwAsmGetVertexList(PWGM_HBLOCKASSEMBLER blkAsm)
{
    return (BLKASMMODEL_IN && BLKASMMODEL_IN->PwAsmGetVertexListCB) ?
        BLKASMMODEL_IN->PwAsmGetVertexListCB(blkAsm) : badVertexList;
}
 
 
PWGM_HBLOCK
PwModCreateStrBlock(PWGM_HGRIDMODEL model, const PWGM_STR_SIZE blkSize)
{
    return (MODEL_IN && MODEL_IN->PwModCreateStrBlockCB) ?
        MODEL_IN->PwModCreateStrBlockCB(model, blkSize) : badBlock;
}
 
 
PWGM_HDOMAIN
PwModCreateStrDomain(PWGM_HGRIDMODEL model, const PWGM_STR_SIZE domSize)
{
    return (MODEL_IN && MODEL_IN->PwModCreateStrDomainCB) ?
        MODEL_IN->PwModCreateStrDomainCB(model, domSize) : badDomain;
}
 
#endif // !defined(PWGM_HIDE_IMPORT_API)