CaeUnsElement.h

Go to the documentation of this file.

/****************************************************************************
 *
 * CaeUnsElement class
 *
 * (C) 2021 Cadence Design Systems, Inc. All rights reserved worldwide.
 *
 ***************************************************************************/
 
#if !defined(PWGM_HIDE_UNSTRUCTURED_API)
 
#ifndef _CAEUNSELEMENT_H_
#define _CAEUNSELEMENT_H_
 
#include <algorithm>
#include <vector>
 
#include "apiGridModel.h"
#include "apiPWP.h"
#include "CaeUnsElementGroup.h"
#include "CaeUnsGridModel.h"
 
 
//***************************************************************************
//***************************************************************************
//***************************************************************************
 
class CaeUnsElementData {
public:
 
    static const PWP_UINT32 MaxNumVerts = PWGM_ELEMDATA_VERT_SIZE;
 
 
    enum ElementType {
        Bar        = PWGM_ELEMTYPE_BAR,     
        Hex        = PWGM_ELEMTYPE_HEX,     
        Quad       = PWGM_ELEMTYPE_QUAD,    
        Tri        = PWGM_ELEMTYPE_TRI,     
        Tet        = PWGM_ELEMTYPE_TET,     
        Wedge      = PWGM_ELEMTYPE_WEDGE,   
        Pyramid    = PWGM_ELEMTYPE_PYRAMID, 
        Point      = PWGM_ELEMTYPE_POINT,   
        Polyhedron = PWGM_ELEMTYPE_POLYH,   
        Polygon    = PWGM_ELEMTYPE_POLYG,   
 
        NumTypes = PWGM_ELEMTYPE_SIZE,  
        LastType = NumTypes - 1,        
        Invalid = NumTypes              
    };
 
 
public:
 
 
    CaeUnsElementData()
    {
        eed_.elemData.type = static_cast<PWGM_ENUM_ELEMTYPE>(Invalid);
        eed_.elemData.vertCnt = 0;
        static const PWGM_HVERTEX bad = PWGM_HVERTEX_INIT;
        std::fill(eed_.elemData.vert, eed_.elemData.vert + MaxNumVerts, bad);
        std::fill(eed_.elemData.index, eed_.elemData.index + MaxNumVerts, 0);
        PWGM_HELEMENT_SET_INVALID(eed_.hBlkElement);
    }
 
 
    CaeUnsElementData(const CaeUnsElementData &src)
    {
        eed_ = src.eed_;
    }
 
 
    CaeUnsElementData(const PWGM_ELEMDATA &ed)
    {
        eed_.elemData = ed;
        PWGM_HELEMENT_SET_INVALID(eed_.hBlkElement);
    }
 
 
    ~CaeUnsElementData()
    {
    }
 
 
    inline ElementType
    type() const
    {
        return static_cast<ElementType>(eed_.elemData.type);
    }
 
 
    inline PWP_UINT32
    vertCount() const
    {
        return eed_.elemData.vertCnt;
    }
 
 
    inline PWGM_HVERTEX
    vertAt(PWP_UINT32 ndx) const
    {
        return eed_.elemData.vert[ndx];
    }
 
 
    inline PWP_UINT32
    indexAt(PWP_UINT32 ndx) const
    {
        return eed_.elemData.index[ndx];
    }
 
 
    inline bool
    isOfType(PWGM_ENUM_ELEMTYPE type) const
    {
        return eed_.elemData.type == type;
    }
 
 
    inline bool
    isOfType(ElementType type) const
    {
        return static_cast<ElementType>(eed_.elemData.type) == type;
    }
 
 
    inline bool
    isValid() const
    {
        return static_cast<ElementType>(eed_.elemData.type) != Invalid;
    }
 
 
    inline PWGM_ELEMDATA&
    elementData()
    {
        return eed_.elemData;
    }
 
 
    inline const PWGM_ELEMDATA&
    elementData() const
    {
        return eed_.elemData;
    }
 
 
    inline CaeUnsElementData&
    operator=(const CaeUnsElementData &src)
    {
        eed_ = src.eed_;
        return *this;
    }
 
 
    inline CaeUnsElementData&
    operator=(const PWGM_ELEMDATA &ed)
    {
        eed_.elemData = ed;
        PWGM_HELEMENT_SET_INVALID(eed_.hBlkElement);
        return *this;
    }
 
 
    inline operator PWGM_ELEMDATA&()
    {
        return eed_.elemData;
    }
 
 
    inline operator const PWGM_ELEMDATA&() const
    {
        return eed_.elemData;
    }
 
 
    template< typename FTOR >
    void
    walkPolyhedronFaces(const FTOR &f)
    {
        PWGM_POLYELEMDATA ped;
        if (PwElemDataCastToPoly(&eed_.elemData, &ped)) {
            walkPolyhedronFaces(ped, f);
        }
    }
 
 
    template< typename FTOR >
    static void
    walkPolyhedronFaces(const PWGM_POLYELEMDATA &ped, const FTOR &f)
    {
        std::vector<PWP_UINT64> globalIndices;
        for (PWP_UINT64 ii = 0; ii < ped.numFaces; ++ii) {
            const PWP_UINT64 NumVerts = ped.offsets[ii + 1] - ped.offsets[ii];
            if (NumVerts < 3) {
                // BAD - not a tri, quad, or polygon!
                ASSERT(false);
                continue;
            }
            globalIndices.resize(NumVerts);
            const PWP_UINT64* loc = &ped.faceIndices[ped.offsets[ii]];
            for (PWP_UINT64 jj = 0; jj < NumVerts; ++jj) {
                globalIndices[jj] = ped.indices[loc[jj]];
            }
            if (!f(NumVerts, globalIndices.data())) {
                // f() wants to stop walking
                break;
            }
        }
    }
 
 
protected:
 
    CaeUnsElementData(const PWGM_ELEMDATA &ed, const PWGM_HELEMENT &he)
    {
        eed_.elemData = ed;
        eed_.hBlkElement = he;
    }
 
 
protected:
 
    PWGM_ENUMELEMDATA   eed_;
};
 
 
//***************************************************************************
//***************************************************************************
//***************************************************************************
 
class CaeUnsEnumElementData : public CaeUnsElementData {
public:
 
 
    CaeUnsEnumElementData() :
        CaeUnsElementData()
    {
    }
 
 
    CaeUnsEnumElementData(const CaeUnsEnumElementData &src) :
        CaeUnsElementData(src.eed_.elemData, src.eed_.hBlkElement)
    {
    }
 
 
    CaeUnsEnumElementData(const PWGM_ENUMELEMDATA &eed) :
        CaeUnsElementData(eed.elemData, eed.hBlkElement)
    {
    }
 
 
    ~CaeUnsEnumElementData()
    {
    }
 
    inline CaeUnsEnumElementData&
    operator=(const CaeUnsEnumElementData &src)
    {
        eed_ = src.eed_;
        return *this;
    }
 
 
    inline CaeUnsEnumElementData&
    operator=(const PWGM_ENUMELEMDATA &eed)
    {
        eed_ = eed;
        return *this;
    }
 
 
    inline PWGM_ENUMELEMDATA& enumElementData()
    {
        return eed_;
    }
 
 
    inline const PWGM_ENUMELEMDATA& enumElementData() const
    {
        return eed_;
    }
 
 
    inline PWGM_HELEMENT& blockElement()
    {
        return eed_.hBlkElement;
    }
 
 
    inline const PWGM_HELEMENT& blockElement() const
    {
        return eed_.hBlkElement;
    }
 
 
 
    inline PWP_UINT32 blockId() const
    {
        return PWGM_HELEMENT_PID(eed_.hBlkElement);
    }
 
 
    inline operator PWGM_ENUMELEMDATA&()
    {
        return eed_;
    }
 
 
    inline operator const PWGM_ENUMELEMDATA&() const
    {
        return eed_;
    }
 
 
    inline operator PWGM_HELEMENT&()
    {
        return eed_.hBlkElement;
    }
 
 
    inline operator const PWGM_HELEMENT&() const
    {
        return eed_.hBlkElement;
    }
};
 
 
//***************************************************************************
//***************************************************************************
//***************************************************************************
 
class CaeUnsElement {
public:
 
 
    CaeUnsElement() : group_(0) {
        PWGM_HELEMENT_SET_INVALID(h_);
    }
 
 
    CaeUnsElement(const CaeUnsElementGroup &group, PWP_UINT32 ndx = 0) :
            group_(&group) {
        h_ = group_->enumElements(ndx);
    }
 
 
    CaeUnsElement(const CaeUnsElement &src) {
        group_ = src.group_;
        h_ = src.h_;
    }
 
    virtual ~CaeUnsElement() {
    }
 
    CaeUnsGridModel model() const {
        return CaeUnsGridModel(PWGM_HELEMENT_MODEL(h_));
    }
 
 
    PWP_UINT32 index() const {
        return PWGM_HELEMENT_ID(h_);
    }
 
 
    bool data(PWGM_ELEMDATA &data) const {
        return 0 != PwElemDataMod(h_, &data);
    }
 
 
    bool data(CaeUnsElementData &data) const {
        return 0 != PwElemDataMod(h_, &data.elementData());
    }
 
 
    bool data(PWGM_ENUMELEMDATA &data) const {
        return 0 != PwElemDataModEnum(h_, &data);
    }
 
 
    bool data(CaeUnsEnumElementData &data) const {
        return 0 != PwElemDataModEnum(h_, &data.enumElementData());
    }
 
    bool isValid() const {
        return PWGM_HELEMENT_ISVALID(h_);
    }
 
 
    CaeUnsElement& operator=(const CaeUnsElement& rhs) {
        group_ = rhs.group_;
        h_ = rhs.h_;
        return *this;
    }
 
 
    CaeUnsElement& moveTo(const CaeUnsElementGroup &group, PWP_UINT32 ndx) {
        group_ = &group;
        h_ = group_->enumElements(ndx);
        return *this;
    }
 
 
    CaeUnsElement& moveFirst(const CaeUnsElementGroup &group) {
        group_ = &group;
        h_ = group_->enumElements(0);
        return *this;
    }
 
 
    CaeUnsElement& moveNext() {
        if (0 != group_) {
            h_ = group_->enumElements(index() + 1);
        }
        return *this;
    }
 
 
    CaeUnsElement& operator++() { // pre incr to next element
        if (0 != group_) {
            h_ = group_->enumElements(index() + 1);
        }
        return *this;
    }
 
 
    CaeUnsElement operator++(int) { // post incr to next element
        CaeUnsElement ret = *this;
        if (0 != group_) {
            h_ = group_->enumElements(index() + 1);
        }
        return ret;
    }
 
 
    CaeUnsElement& movePrev() { // move to previous element
        if (0 != group_) {
            h_ = group_->enumElements(index() - 1);
        }
        return *this;
    }
 
 
    CaeUnsElement& operator--() { // pre decr to previous element
        if (0 != group_) {
            h_ = group_->enumElements(index() - 1);
        }
        return *this;
    }
 
 
    CaeUnsElement operator--(int) { // post decr to previous element
        CaeUnsElement ret = *this;
        if (0 != group_) {
            h_ = group_->enumElements(index() - 1);
        }
        return ret;
    }
 
    friend bool operator==(const PWGM_HELEMENT &h1, const PWGM_HELEMENT &h2);
    friend bool operator<(const PWGM_HELEMENT &h1, const PWGM_HELEMENT &h2);
 
 
    bool operator==(const CaeUnsElement &rhs) const {
        return (rhs.group_ == group_) && (rhs.h_ == h_);
    }
 
 
    bool operator!=(const CaeUnsElement &rhs) const {
        return !(rhs == *this);
    }
 
 
    bool operator<(const CaeUnsElement &rhs) const {
        if (rhs.group_ < group_) {
            return true;
        }
        else if (rhs.group_ > group_) {
            return false;
        }
        return h_ < rhs.h_;
    }
 
 
    bool operator>(const PWGM_HELEMENT &rhs)
    {
        return !(*this == rhs) && !(*this < rhs);
    }
 
    operator PWGM_HELEMENT() const {
        return h_;
    }
 
private:
 
    const CaeUnsElementGroup *  group_; 
    PWGM_HELEMENT               h_;     
};
 
#endif // _CAEUNSELEMENT_H_
 
#endif // PWGM_HIDE_UNSTRUCTURED_API