CaeUnsGridModel.cxx

Go to the documentation of this file.

/****************************************************************************
 *
 * CaeUnsGridModel class
 *
 * (C) 2021 Cadence Design Systems, Inc. All rights reserved worldwide.
 *
 ***************************************************************************/
 
#if !defined(PWGM_HIDE_UNSTRUCTURED_API)
 
#include "apiGridModel.h"
#include "apiPWP.h"
 
#include "CaeGridModel.h"
#include "CaeUnsGridModel.h"
 
 
//***************************************************************************
//***************************************************************************
//***************************************************************************
 
CaeUnsGridModel::CaeUnsGridModel(PWGM_HGRIDMODEL model) :
    CaeGridModel(model)
{
}
 
 
CaeUnsGridModel::CaeUnsGridModel(const CaeUnsGridModel &src) :
    CaeGridModel(src.model_)
{
}
 
 
CaeUnsGridModel::~CaeUnsGridModel()
{
}
 
 
PWP_UINT32
CaeUnsGridModel::patchCount() const
{
    return PwModDomainCount(model_);
}
 
 
PWP_UINT32
CaeUnsGridModel::vertexCount() const
{
    return PwModVertexCount(model_);
}
 
 
 
static PWP_UINT32
beginCB(PWGM_BEGINSTREAM_DATA *data)
{
    CaeFaceStreamHandler *handler = (CaeFaceStreamHandler*)data->userData;
    return handler->streamBegin(*data);
}
 
 
static PWP_UINT32
faceCB(PWGM_FACESTREAM_DATA *data)
{
    CaeFaceStreamHandler *handler = (CaeFaceStreamHandler*)data->userData;
    return handler->streamFace(*data);
}
 
 
static PWP_UINT32
endCB(PWGM_ENDSTREAM_DATA *data)
{
    CaeFaceStreamHandler *handler = (CaeFaceStreamHandler*)data->userData;
    return handler->streamEnd(*data);
}
 
 
bool
CaeUnsGridModel::streamFaces(PWGM_ENUM_FACEORDER order,
   CaeFaceStreamHandler &handler) const
{
    return 0 != PwModStreamFaces(model_, order, beginCB, faceCB, endCB,
                    &handler);
}
 
 
 
static PWP_UINT64
ndxMapperCB(const PWP_UINT64 pwgmNdx, void *data)
{
    CaeUnsCustomIndexHandler *handler = (CaeUnsCustomIndexHandler*)data;
    return handler->mapIndex(pwgmNdx);
}
 
bool
CaeUnsGridModel::customIndexSchemeReady(CaeUnsCustomIndexHandler &handler) const
{
    return 0 != PwModCustomIndexSchemeReady(model_, ndxMapperCB, &handler);
}
 
 
 
bool
CaeUnsGridModel::appendEnumElementOrder(PWGM_ENUM_ELEMORDER order) const
{
    return 0 != PwModAppendEnumElementOrder(model_, order);
}
 
 
PWP_VOID
CaeUnsGridModel::defaultEnumElementOrder() const
{
    return PwModDefaultEnumElementOrder(model_);
}
 
 
PWP_UINT32
CaeUnsGridModel::patchElementCount(PWGM_ELEMCOUNTS *pDetails) const
{
    PWP_UINT32 ret = 0;
    CaeUnsPatch patch(*this);
    if (nullptr == pDetails) {
        // no details wanted
        while (patch.isValid()) {
            ret += patch.elementCount(nullptr);
            ++patch;
        }
    }
    else {
        PWGM_ELEMCOUNTS cnts;
        while (patch.isValid()) {
            ret += patch.elementCount(&cnts);
            PWGM_ECNT_Bar(*pDetails) += PWGM_ECNT_Bar(cnts);
            PWGM_ECNT_Tri(*pDetails) += PWGM_ECNT_Tri(cnts);
            PWGM_ECNT_Quad(*pDetails) += PWGM_ECNT_Quad(cnts);
            PWGM_ECNT_Polygon(*pDetails) += PWGM_ECNT_Polygon(cnts);
            ++patch;
        }
    }
    return ret;
}
 
 
CaeUnsGridModel &
CaeUnsGridModel::operator=(const CaeUnsGridModel &rhs)
{
    model_ = rhs.model_;
    return *this;
}
 
 
//***************************************************************************
//***************************************************************************
//***************************************************************************
 
// data layout for PWGM_HELEMENT:
//   struct PWGM_HELEMENT {
//       struct PWGM_HELEMENT_BASE parent {
//           PWGM_HGRIDMODEL hP;
//           PWP_UINT32 id;
//       }
//       unsigned char ptype;
//       PWP_UINT32 id;
//   }
 
bool
operator==(const PWGM_HELEMENT &h1, const PWGM_HELEMENT &h2)
{
    // for speed, compare ids first. This assumes that most compares will
    // differ in ids. Only if ids are the same will the remaining, more
    // expensive compares be performed.
    return (PWGM_HELEMENT_ID(h1) == PWGM_HELEMENT_ID(h2)) &&    // .id 
        (PWGM_HELEMENT_PID(h1) == PWGM_HELEMENT_PID(h2)) &&     // parent.id
        (PWGM_HELEMENT_PTYPE(h1) == PWGM_HELEMENT_PTYPE(h2)) && // .type
        (PWGM_HELEMENT_OUT_GMIMPL(h1) == PWGM_HELEMENT_OUT_GMIMPL(h2)); // parent.hP
}
 
 
bool
operator!=(const PWGM_HELEMENT &h1, const PWGM_HELEMENT &h2)
{
    return !(h1 == h2);
}
 
 
bool
operator<(const PWGM_HELEMENT &h1, const PWGM_HELEMENT &h2)
{
    // for speed, compare ids first. This assumes that most compares will
    // differ in ids. Only if ids are the same will the remaining, more
    // expensive compares be performed.
    if (PWGM_HELEMENT_ID(h1) < PWGM_HELEMENT_ID(h2)) { // .id 
        return true;
    }
    else if (PWGM_HELEMENT_ID(h1) > PWGM_HELEMENT_ID(h2)) { // .id 
        return false;
    }
    else if (PWGM_HELEMENT_PID(h1) < PWGM_HELEMENT_PID(h2)) { // parent.id
        return true;
    }
    else if (PWGM_HELEMENT_PID(h1) > PWGM_HELEMENT_PID(h2)) { // parent.id
        return false;
    }
    else if (PWGM_HELEMENT_PTYPE(h1) < PWGM_HELEMENT_PTYPE(h2)) { // .type
        return true;
    }
    else if (PWGM_HELEMENT_PTYPE(h1) > PWGM_HELEMENT_PTYPE(h2)) { // .type
        return false;
    }
    else if (PWGM_HELEMENT_OUT_GMIMPL(h1) < PWGM_HELEMENT_OUT_GMIMPL(h2)) { //parent.hP
        return true;
    }
    return false; // PWGM_HELEMENT_OUT_GMIMPL(h1) >= PWGM_HELEMENT_OUT_GMIMPL(h2)
}
 
 
bool
operator>(const PWGM_HELEMENT &h1, const PWGM_HELEMENT &h2)
{
    return (h1 != h2) && !(h1 < h2);
}
 
 
//***************************************************************************
//***************************************************************************
//***************************************************************************
 
// data layout for PWGM_HVERTEX:
//   struct PWGM_HVERTEX {
//       PWGM_HGRIDMODEL hP;
//       PWP_UINT32 id;
//   }
 
bool
operator==(const PWGM_HVERTEX &h1, const PWGM_HVERTEX &h2)
{
    // for speed, compare ids first. This assumes that most compares will
    // differ in ids. Only if ids are the same will the remaining, more
    // expensive compares be performed.
    return (PWGM_HVERTEX_ID(h1) == PWGM_HVERTEX_ID(h2)) &&    // .id 
        (PWGM_HVERTEX_OUT_GMIMPL(h1) == PWGM_HVERTEX_OUT_GMIMPL(h2)); // .hP
}
 
 
bool
operator!=(const PWGM_HVERTEX &h1, const PWGM_HVERTEX &h2)
{
    return !(h1 == h2);
}
 
 
bool
operator<(const PWGM_HVERTEX &h1, const PWGM_HVERTEX &h2)
{
    // for speed, compare ids first. This assumes that most compares will
    // differ in ids. Only if ids are the same will the remaining, more
    // expensive compares be performed.
    if (PWGM_HVERTEX_ID(h1) < PWGM_HVERTEX_ID(h2)) { // .id 
        return true;
    }
    else if (PWGM_HVERTEX_ID(h1) > PWGM_HVERTEX_ID(h2)) { // .id 
        return false;
    }
    else if (PWGM_HVERTEX_OUT_GMIMPL(h1) < PWGM_HVERTEX_OUT_GMIMPL(h2)) { // parent.hP
        return true;
    }
    return false; // PWGM_HVERTEX_OUT_GMIMPL(h1) >= PWGM_HVERTEX_OUT_GMIMPL(h2)
}
 
 
bool
operator>(const PWGM_HVERTEX &h1, const PWGM_HVERTEX &h2)
{
    return (h1 != h2) && !(h1 < h2);
}
 
#endif // PWGM_HIDE_UNSTRUCTURED_API