MeshModel.h

Go to the documentation of this file.

/****************************************************************************
 *
 * Copyright (c) 2019-2020 Pointwise, Inc.
 * All rights reserved.
 *
 * This sample Pointwise source code is not supported by Pointwise, Inc.
 * It is provided freely for demonstration purposes only.
 * SEE THE WARRANTY DISCLAIMER AT THE BOTTOM OF THIS FILE.
 *
 ***************************************************************************/

#ifndef MESH_MODEL_CLASS
#define MESH_MODEL_CLASS

#include "Types.h"
#include "MeshTopo.h"
#include "MeshString.h"
#include "MeshSheet.h"

#include <algorithm>
#include <map>
#include <string>
#include <vector>
using StringArray = std::vector<std::string>;

/****************************************************************************
 * MeshModel class
 ***************************************************************************/
class ML_STORAGE_CLASS MeshModel : public MeshTopo {
public:
    friend class MeshAssociativity;

    //
    MeshModel(
        std::string &ref,
        MLINT mid,
        MLINT aref,
        MLINT gref,
        std::string &name);

    //
    bool addPoint(MLINT i1,
        MLINT mid,
        MLINT aref,
        MLINT gref,
        std::string &name,
        ParamVertex *pv1, bool mapID);

    //
    bool addPoint(
        std::string &ref,
        MLINT mid,
        MLINT aref,
        MLINT gref,
        std::string &name,
        ParamVertex *pv1, bool mapID);

    MeshPoint *findLowestTopoPointByInd(MLINT i1) const;

    MeshPoint *findHighestTopoPointByInd(MLINT i1) const;

    MeshPoint * findPointByInd(MLINT i1) const;

    void deletePointByInd(MLINT i1);
    void deletePointByRef(const std::string &ref);
    void deletePointByRef(MLINT iref);

    MeshPoint* getMeshPointByName(const std::string &name) const;
    MeshPoint* getMeshPointByID(MLINT id) const;
    MeshPoint* getMeshPointByRef(const std::string &ref) const;

    StringArray getMeshPointRefs() const;

    bool addEdge(MLINT i1, MLINT i2,
        MLINT mid,
        MLINT aref,
        MLINT gref,
        std::string &name,
        ParamVertex *pv1, ParamVertex *pv2, bool mapID);

    //
    bool addEdge(
        std::string &ref,
        MLINT mid,
        MLINT aref,
        MLINT gref,
        std::string &name,
        ParamVertex *pv1, ParamVertex *pv2, bool mapID);

    void addEdgePoint(MLINT i1,
        MLINT mid,
        MLINT aref,
        MLINT gref,
        ParamVertex *pv1);

    void addFaceEdgePoint(MLINT i1,
        MLINT mid,
        MLINT aref,
        MLINT gref,
        ParamVertex *pv1);

    MeshPoint * findEdgePointByInd(MLINT i1) const;

    MeshPoint *findFaceEdgePointByInd(MLINT i1) const;

    void addFaceEdge(MLINT i1, MLINT i2,
        MLINT mid,
        MLINT aref,
        MLINT gref,
        ParamVertex *pv1, ParamVertex *pv2);

    MeshEdge * getMeshEdgeByName(const std::string &name) const;

    MeshEdge * getMeshEdgeByRef(const std::string &ref) const;

    MeshEdge *findLowestTopoEdgeByInds(MLINT i1, MLINT i2) const;

    MeshEdge *findEdgeByInds(MLINT i1, MLINT i2) const;

    MeshEdge *findFaceEdgeByInds(MLINT i1, MLINT i2) const;

    //
    //
    void deleteEdgeByInds(MLINT i1, MLINT i2);

    void deleteEdgeByRef(const std::string &ref);

    void deleteEdgeByRef(MLINT iref);

    bool addFace(MLINT i1, MLINT i2, MLINT i3,
        MLINT mid,
        MLINT aref,
        MLINT gref,
        std::string &name,
        ParamVertex *pv1, ParamVertex *pv2,
        ParamVertex *pv3, bool mapID);

    bool addFace(
        std::string &ref,
        MLINT mid,
        MLINT aref,
        MLINT gref,
        std::string &name,
        ParamVertex *pv1, ParamVertex *pv2,
        ParamVertex *pv3, bool mapID);

    bool addFace(MLINT i1, MLINT i2, MLINT i3, MLINT i4,
        MLINT mid,
        MLINT aref,
        MLINT gref,
        std::string &name,
        ParamVertex *pv1, ParamVertex *pv2,
        ParamVertex *pv3, ParamVertex *pv4, bool mapID);

    bool addFace(
        std::string &ref,
        MLINT mid,
        MLINT aref,
        MLINT gref,
        std::string &name,
        ParamVertex *pv1, ParamVertex *pv2,
        ParamVertex *pv3, ParamVertex *pv4, bool mapID);

    MeshFace *findFaceByInds(MLINT i1, MLINT i2, MLINT i3,
        MLINT i4 = MESH_TOPO_INDEX_UNUSED);

    void deleteFaceByInds(MLINT i1, MLINT i2, MLINT i3,
        MLINT i4 = MESH_TOPO_INDEX_UNUSED);

    void deleteFaceByRef(const std::string &ref);

    //
    void deleteFaceByRef(MLINT iref);

    MeshFace * getMeshFaceByName(const std::string &name) const;

    MeshFace * getMeshFaceByRef(const std::string &ref) const;

    //
    MLINT getNumEdges() const;

    //
    MLINT getNumFaces() const;

    bool addMeshString(MeshString* meshString, bool mapID=false);

    MeshString*     getMeshStringByID(MLINT id) const;

    MeshString*     getMeshStringByName(const std::string &name) const;

    MeshString * getMeshStringByRef(const std::string &ref) const;

    bool addMeshSheet(MeshSheet* meshSheet, bool mapID=false);

    MeshSheet*      getMeshSheetByID(MLINT id) const;

    MeshSheet*      getMeshSheetByName(const std::string &name) const;

    //
    MeshSheet * getMeshSheetByRef(const std::string &ref) const;

    void getMeshEdges(std::vector<const MeshEdge *> &edges) const;

    void getMeshFaces(std::vector<const MeshFace *> &faces) const;

    void getMeshStrings(std::vector<MeshString *> &strings) const;

    size_t getMeshStringCount() const;

    void getMeshSheets(std::vector<MeshSheet *> &sheets) const;

    size_t getMeshSheetCount() const;

    ~MeshModel();

    virtual const std::string &getBaseName() const;
    virtual MLUINT &getNameCounter();

private:
    static MLUINT nameCounter_;

    MeshModel() {};

    std::map<pwiFnvHash::FNVHash, MeshPoint*> pointMap_; // not the owner
    MeshPointNameMap        meshPointNameMap_;  // owner
    MeshTopoIDToNameMap     meshPointIDToNameMap_;
    MeshTopoRefToNameMap    meshPointRefToNameMap_;

    std::map<pwiFnvHash::FNVHash, MeshEdge*> edgeMap_; // not the owner
    MeshEdgeNameMap         meshEdgeNameMap_;  // owner
    MeshTopoIDToNameMap     meshEdgeIDToNameMap_;
    MeshTopoRefToNameMap    meshEdgeRefToNameMap_;

    std::map<pwiFnvHash::FNVHash, MeshPoint*> edgePointMap_; // owner
    std::map<pwiFnvHash::FNVHash, MeshPoint*> faceEdgePointMap_; // owner


    std::map<pwiFnvHash::FNVHash, MeshEdge*> faceEdgeMap_; // owner

    std::map<pwiFnvHash::FNVHash, MeshFace*> faceMap_; // not the owner
    MeshFaceNameMap         meshFaceNameMap_;  // owner
    MeshTopoIDToNameMap     meshFaceIDToNameMap_;
    MeshTopoRefToNameMap    meshFaceRefToNameMap_;

    MeshStringNameMap       meshStringNameMap_;
    MeshTopoIDToNameMap     meshStringIDToNameMap_;
    MeshTopoRefToNameMap    meshStringRefToNameMap_;

    MeshSheetNameMap        meshSheetNameMap_;
    MeshTopoIDToNameMap     meshSheetIDToNameMap_;
    MeshTopoRefToNameMap    meshSheetRefToNameMap_;
};

typedef std::map<std::string, MeshModel *> MeshModelNameMap;

#endif

/****************************************************************************
 *
 * DISCLAIMER:
 * TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, POINTWISE DISCLAIMS
 * ALL WARRANTIES, EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED
 * TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE, WITH REGARD TO THIS SCRIPT. TO THE MAXIMUM EXTENT PERMITTED
 * BY APPLICABLE LAW, IN NO EVENT SHALL POINTWISE BE LIABLE TO ANY PARTY
 * FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
 * WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF
 * BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE
 * USE OF OR INABILITY TO USE THIS SCRIPT EVEN IF POINTWISE HAS BEEN
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGES AND REGARDLESS OF THE
 * FAULT OR NEGLIGENCE OF POINTWISE.
 *
 ***************************************************************************/