Xdmf.h

Go to the documentation of this file.

#ifndef included_AMP_XDMF
#define included_AMP_XDMF
 
#include "AMP/IO/HDF.h"
#include "AMP/utils/AMP_MPI.h"
#include "AMP/utils/Array.h"
 
#include <map>
#include <stdio.h>
#include <stdlib.h>
#include <vector>
 
 
namespace AMP {
 
 
// Helper class to write/read XDMF files
class Xdmf
{
public:
    enum class TopologyType {
        Null = 0,
        Polyvertex,
        Polyline,
        Polygon,
        Triangle,
        Quadrilateral,
        Tetrahedron,
        Pyramid,
        Wedge,
        Hexahedron,
        Edge_3,
        Triangle_6,
        Quadrilateral_8,
        Tetrahedron_10,
        Pyramid_13,
        Wedge_15,
        Hexahedron_20,
        Mixed,
        CurvilinearMesh2D,
        CurvilinearMesh3D,
        RectangularMesh2D,
        RectangularMesh3D,
        UniformMesh2D,
        UniformMesh3D,
    };
    enum class DataType { Null = 0, Char, Int32, Int64, Uint32, Uint64, Float, Double };
    enum class RankType { Null = 0, Scalar, Vector, Tensor, Tensor6, Matrix, GlobalID };
    enum class Center { Null = 0, Node, Edge, Face, Cell, Grid, Other };
 
    struct VarData {
        std::string name;  // Variable name
        ArraySize size;    // Size of variable
        RankType rankType; // Rank order of data
        Center center;     // Variable centering
        std::string data;  // Variable data
    };
 
    struct MeshData {
        std::string name;          // Name of mesh domain
        TopologyType type;         // Type of mesh
        ArraySize size;            // Size of mesh (meaning depends on mesh type)
        double range[6];           // Range of the mesh (only used for UniformMesh2D/UniformMesh3D)
        std::string x;             // x coordinates (or xy/xyz coordinates)
        std::string y;             // y coordinates
        std::string z;             // z coordinates
        std::string dofMap;        // mesh connectivity
        std::vector<VarData> vars; // Variables
        MeshData() : type( TopologyType::Null ), range{ 0 } {}
        void addVariable( const std::string &varName,
                          const ArraySize &varSize,
                          RankType rank,
                          Center center,
                          const std::string &varData );
    };
 
 
public:
    static MeshData createPointMesh( const std::string &name,
                                     uint8_t NDIM,
                                     size_t N,
                                     const std::string &x,
                                     const std::string &y = "",
                                     const std::string &z = "" );
 
    static MeshData createUniformMesh( const std::string &name,
                                       const std::vector<double> &range,
                                       const ArraySize &size );
 
    static MeshData createCurvilinearMesh( const std::string &name,
                                           const ArraySize &size,
                                           const std::string &x,
                                           const std::string &y = "",
                                           const std::string &z = "" );
 
    static MeshData createUnstructuredMesh( const std::string &name,
                                            uint8_t NDIM,
                                            TopologyType type,
                                            size_t NumElements,
                                            const std::string &dofMap,
                                            size_t NumNodes,
                                            const std::string &x,
                                            const std::string &y = "",
                                            const std::string &z = "" );
 
public:
    void addMesh( const std::string &meshName, const MeshData &domain );
 
    void addMultiMesh( const std::string &meshName, const std::vector<std::string> &submeshes );
 
    void addMultiMesh( const std::string &meshName, const std::vector<MeshData> &submeshes );
 
    void gather( const AMP::AMP_MPI &comm );
 
    void write( const std::string &filename ) const;
 
    void clear();
 
    bool empty() const { return d_meshData.empty(); }
 
private:
    std::map<std::string, std::vector<MeshData>> d_meshData;
};
 
 
} // namespace AMP
 
#endif