MeshAssociativity.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_ASSOCIATIVITY_CLASS
#define MESH_ASSOCIATIVITY_CLASS

#include "Types.h"
#include "GeometryGroup.h"
#include "GeometryKernel.h"
#include "MeshModel.h"

#include <stdio.h>
#include <string>
#include <vector>

class GeometryKernelManager;
class MeshAssociativity;

/****************************************************************************
 * MeshLinkTransform class
 ***************************************************************************/
class ML_STORAGE_CLASS MeshLinkTransform {
public:
    friend class MeshAssociativity;

    MeshLinkTransform();

    MeshLinkTransform(MLINT xid, std::string &name, std::string &contents,
        MeshAssociativity &meshAssoc);

    virtual void setAref(MLINT aref);

    bool hasAref() const;

    MLINT getAref() const;

    MLINT getXID() const;

    const std::string & getName() const;

    const std::string & getContents() const;

    bool isValid() const { return is_valid_; }

    void getQuaternion(MLREAL xform_quaternion[4][4]) const;

private:
    MLINT xid_;
    std::string name_;
    MLINT aref_;
    std::string contents_;
    MLREAL xform_[4][4];
    bool is_valid_;
};


/****************************************************************************
 * MeshElementLinkage class
 ***************************************************************************/
class ML_STORAGE_CLASS MeshElementLinkage {
public:
    friend class MeshAssociativity;

    MeshElementLinkage();

    MeshElementLinkage(std::string &name, 
        std::string &sourceEntityRef,
        std::string &targetEntityRef,
        MeshAssociativity &meshAssoc);

    virtual void setAref(MLINT aref);

    bool hasAref() const;

    MLINT getAref() const;

    virtual bool setXref(MLINT xref, MeshAssociativity &meshAssoc);

    bool hasXref() const;

    virtual bool getXref(MLINT *xref) const;

    const MeshLinkTransform * getTransform(const MeshAssociativity &meshAssoc) const;

    bool isValid() const { return is_valid_; }

    virtual void getName(const char **name) const;

    virtual const std::string & getName() const;

    void setName(const std::string &name);

    //
    void setName(const char *name);

    std::string getNextName();

    void getEntityRefs(std::string &sourceEntityRef, std::string &targetEntityRef) const;

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

private:
    static MLUINT nameCounter_;

    std::string name_;
    MLINT aref_;
    MLINT xref_;
    std::string sourceEntityRef_;
    std::string targetEntityRef_;
    bool is_valid_;
};

/****************************************************************************
 * MeshLinkAttribute class
 ***************************************************************************/
class ML_STORAGE_CLASS MeshLinkAttribute {
public:
    friend class MeshAssociativity;

    MeshLinkAttribute();

    MeshLinkAttribute(MLINT attid, std::string &name, std::string &contents,
        bool is_group, MeshAssociativity &meshAssoc);

    MLINT getAttID() const;

    bool isGroup() const;

    bool isValid() const;

    const std::vector<MLINT> & getAttributeIDs() const;
private:

    bool buildGroupArefs(MeshAssociativity &meshAssoc);

    MLINT attid_;
    std::string name_;
    std::string contents_;
    bool is_group_;
    bool is_valid_;
    std::vector<MLINT> group_arefs_;
};


/****************************************************************************
 * MeshLinkFile class
 ***************************************************************************/
class ML_STORAGE_CLASS MeshLinkFile {
public:
    friend class MeshAssociativity;

    MeshLinkFile() {};

    MeshLinkFile(std::string &filename, std::string &arefString):
        filename_(filename),
        arefString_(arefString)
    {};

    ~MeshLinkFile() {};

    virtual const char *getFilename() const { return filename_.c_str(); }

    std::vector<MLINT> getAttributeIDs(const MeshAssociativity &meshAssoc) const;

    bool hasAref() const { return !arefString_.empty(); }

    bool getArefID(MLINT *aref) const {
        if (!hasAref()) { return false; }
        if (1 == sscanf(arefString_.c_str(), "%" MLINT_FORMAT, aref)) {
            return true;
        }
        return false;
    }

protected:
    std::string filename_;

    std::string arefString_;
};

/****************************************************************************
* GeometryFile class
***************************************************************************/
class ML_STORAGE_CLASS GeometryFile : public MeshLinkFile {
public:
    GeometryFile() {};

    GeometryFile(std::string &filename, std::string &arefString) :
        MeshLinkFile(filename, arefString)
    {};

    ~GeometryFile() {};

    void addGeometryGroupID(MLINT gid) {
        groupIDs_.push_back(gid);
    }

    const std::vector<MLINT> &getGeometryGroupIDs() const
    {
        return groupIDs_;
    }
private:
    std::vector<MLINT> groupIDs_;
};

/****************************************************************************
* MeshFile class
***************************************************************************/
class ML_STORAGE_CLASS MeshFile : public MeshLinkFile {
public:
    MeshFile() {};

    MeshFile(std::string &filename, std::string &arefString) :
        MeshLinkFile(filename, arefString)
    {};

    ~MeshFile() {};

    void addModelRef(const std::string &refName) {
        modelRefs_.push_back(refName);
    }

    // \brief Return the list of mesh model references associated with this mesh file
    const std::vector<std::string> &getModelRefs() {
        return modelRefs_;
    }

private:
    std::vector<std::string> modelRefs_;
};


typedef std::map<std::string, MLINT> MeshAttributeNameToIDMap;
typedef std::map<MLINT, MeshLinkAttribute> MeshAttributeIDMap;

typedef std::map<std::string, MLINT> MeshTransformNameToIDMap;
typedef std::map<MLINT, MeshLinkTransform> MeshTransformIDMap;
typedef std::map<std::string, MeshElementLinkage *> MeshElementLinkageNameMap;


/****************************************************************************
 * MeshAssociativity class
 ***************************************************************************/
class ML_STORAGE_CLASS MeshAssociativity {
public:
    MeshAssociativity() {}

    ~MeshAssociativity();

    bool addGeometryGroup(GeometryGroup &geometry_group);

    MLINT getGeometryGroupCount() const;

    void getGeometryGroupIDs(std::vector<MLINT> &gids) const;

    GeometryGroup * getGeometryGroupByName(const char *name);

    GeometryGroup * getGeometryGroupByID(MLINT id);

    bool addMeshModel(MeshModel *model, bool mapID);

    MeshModel * getMeshModelByID(MLINT id) const;

    MeshModel * getMeshModelByName(const std::string &name) const;

    MeshModel* getMeshModelByRef(const char * ref) const;

    bool getMeshSheetByName(const std::string &name,
        MeshModel **model, MeshSheet **sheet) const;

    bool getMeshStringByName(const std::string &name,
        MeshModel **model, MeshString **string) const;

    void addGeometryKernel(GeometryKernel *kernel);

    void removeGeometryKernel(GeometryKernel *kernel);

    GeometryKernel * getGeometryKernelByName(const char *name);

    GeometryKernel * getActiveGeometryKernel();

    bool setActiveGeometryKernelByName(const char *name);

    const MeshLinkAttribute * getAttributeByID(const MLINT id) const;

    void clearAttributes();

    bool addAttribute(MeshLinkAttribute &att);

    std::vector<const MeshLinkAttribute *> getAttributes() const;


    const MeshLinkTransform * getTransformByID(const MLINT id) const;

    void clearTransforms();

    bool addTransform(MeshLinkTransform &att);

    void getTransforms(std::vector<const MeshLinkTransform *> &xforms) const;

    size_t  getTransformCount() const;


    void clearMeshElementLinkages();

    bool addMeshElementLinkage(MeshElementLinkage *linkage);


    MeshElementLinkage*
        getMeshElementLinkageByName(const std::string &name) const;


    void getMeshElementLinkages(std::vector<MeshElementLinkage *> &linkages) const;

    size_t  getMeshElementLinkageCount() const;

    MLINT getNumGeometryFiles() const;

    void addGeometryFile(GeometryFile &file);

    MLINT getNumMeshFiles() const;

    void addMeshFile(MeshFile &file);

    bool getAttribute(MLINT attID, const char **name, const char **value) const;

    const std::vector<GeometryFile> & getGeometryFiles() const;

    const std::vector<MeshFile> & getMeshFiles() const;

    void getMeshModels(std::vector<MeshModel *> &models) const;

    size_t getMeshModelCount() const;

private:
    std::vector<GeometryFile> geometryFiles_;
    std::vector<MeshFile> meshFiles_;

    static GeometryKernelManager geometry_kernel_manager_;

    GeometryGroupManager geometry_group_manager_;

    MeshAttributeIDMap meshAttributeIDMap_;
    MeshAttributeNameToIDMap meshAttributeNameToIDMap_;

    MeshTransformIDMap meshTransformIDMap_;
    MeshTransformNameToIDMap meshTransformNameToIDMap_;

    MeshElementLinkageNameMap   meshElementLinkageNameMap_;


    MeshModelNameMap   meshModelNameMap_;
    MeshTopoIDToNameMap   meshModelIDToNameMap_;
    MeshTopoRefToNameMap    meshModelRefToNameMap_;
};



/****************************************************************************
 * GeometryKernelManager class
 ***************************************************************************/
using GeometryKernelArray = std::vector<GeometryKernel *>;

class GeometryKernelManager {
public:
    friend class MeshAssociativity;
    GeometryKernelManager() :
        active_(NULL)
    {};

private:
    void addKernel(GeometryKernel *kernel);

    void removeKernel(GeometryKernel *kernel);

    GeometryKernel * getByName(const char *name);

    GeometryKernel * getActive();

    bool setActiveByName(const char *name);

    GeometryKernelArray geometry_kernels_;
    GeometryKernel * active_;
};

#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.
 *
 ***************************************************************************/