MeshEnums.cpp

/**
 * \file
 * \author Karsten Rink
 * \date   2012-05-02
 * \brief  Implementation of mesh-related enumerations.
 *
 * \copyright
 * Copyright (c) 2012-2016, OpenGeoSys Community (http://www.opengeosys.org)
 *            Distributed under a Modified BSD License.
 *              See accompanying file LICENSE.txt or
 *              http://www.opengeosys.org/project/license
 *
 */

#include "MeshEnums.h"

namespace MeshLib {

const std::string MeshElemType2String(const MeshElemType t)
{
    if (t == MeshElemType::POINT)
        return "Point";
    if (t == MeshElemType::LINE)
        return "Line";
    if (t == MeshElemType::QUAD)
        return "Quad";
    if (t == MeshElemType::HEXAHEDRON)
        return "Hexahedron";
    if (t == MeshElemType::TRIANGLE)
        return "Triangle";
    if (t == MeshElemType::TETRAHEDRON)
        return "Tetrahedron";
    if (t == MeshElemType::PRISM)
        return "Prism";
    if (t == MeshElemType::PYRAMID)
        return "Pyramid";
    return "none";
}

const std::string MeshElemType2StringShort(const MeshElemType t)
{
    if (t == MeshElemType::POINT)
        return "point";
    if (t == MeshElemType::LINE)
        return "line";
    if (t == MeshElemType::QUAD)
        return "quad";
    if (t == MeshElemType::HEXAHEDRON)
        return "hex";
    if (t == MeshElemType::TRIANGLE)
        return "tri";
    if (t == MeshElemType::TETRAHEDRON)
        return "tet";
    if (t == MeshElemType::PRISM)
        return "pris";
    if (t == MeshElemType::PYRAMID)
        return "pyra";
    return "none";
}

MeshElemType String2MeshElemType(const std::string &s)
{
    if ((s.compare("point") == 0) || (s.compare("Point") == 0))
        return MeshElemType::POINT;
    if ((s.compare("line") == 0) || (s.compare("Line") == 0))
        return MeshElemType::LINE;
    if ((s.compare("quad") == 0) || (s.compare("Quadrilateral") == 0))
        return MeshElemType::QUAD;
    if ((s.compare("hex")  == 0) || (s.compare("Hexahedron") == 0))
        return MeshElemType::HEXAHEDRON;
    if ((s.compare("tri")  == 0) || (s.compare("Triangle") == 0))
        return MeshElemType::TRIANGLE;
    if ((s.compare("tet")  == 0) || (s.compare("Tetrahedron") == 0))
        return MeshElemType::TETRAHEDRON;
    if ((s.compare("pris") == 0) || (s.compare("Prism") == 0))
        return MeshElemType::PRISM;
    if ((s.compare("pyra") == 0) || (s.compare("Pyramid") == 0))
        return MeshElemType::PYRAMID;
    return MeshElemType::INVALID;
}

std::vector<MeshElemType> getMeshElemTypes()
{
    std::vector<MeshElemType> vec;
    vec.push_back(MeshElemType::POINT);
    vec.push_back(MeshElemType::LINE);
    vec.push_back(MeshElemType::QUAD);
    vec.push_back(MeshElemType::HEXAHEDRON);
    vec.push_back(MeshElemType::TRIANGLE);
    vec.push_back(MeshElemType::TETRAHEDRON);
    vec.push_back(MeshElemType::PRISM);
    vec.push_back(MeshElemType::PYRAMID);
    return vec;
}

std::vector<std::string> getMeshElemTypeStringsShort()
{
    std::vector<std::string> vec;
    for (MeshElemType eleType : getMeshElemTypes())
        vec.push_back(MeshElemType2StringShort(eleType));
    return vec;
}

const std::string CellType2String(const CellType t)
{
#define RETURN_CELL_TYPE_STR(t, type)\
    if ((t) == CellType::type)\
        return #type;

    RETURN_CELL_TYPE_STR(t, POINT1);
    RETURN_CELL_TYPE_STR(t, LINE2);
    RETURN_CELL_TYPE_STR(t, LINE3);
    RETURN_CELL_TYPE_STR(t, QUAD4);
    RETURN_CELL_TYPE_STR(t, QUAD8);
    RETURN_CELL_TYPE_STR(t, QUAD9);
    RETURN_CELL_TYPE_STR(t, HEX8);
    RETURN_CELL_TYPE_STR(t, HEX20);
    RETURN_CELL_TYPE_STR(t, HEX27);
    RETURN_CELL_TYPE_STR(t, TRI3);
    RETURN_CELL_TYPE_STR(t, TRI6);
    RETURN_CELL_TYPE_STR(t, TET4);
    RETURN_CELL_TYPE_STR(t, TET10);
    RETURN_CELL_TYPE_STR(t, PRISM6);
    RETURN_CELL_TYPE_STR(t, PRISM15);
    RETURN_CELL_TYPE_STR(t, PYRAMID5);
    RETURN_CELL_TYPE_STR(t, PYRAMID13);

    return "none";

#undef RETURN_CELL_TYPE_STR
}

const std::string MeshQualityType2String(const MeshQualityType t)
{
    if (t == MeshQualityType::ELEMENTSIZE)
        return "ElementSize";
    if (t == MeshQualityType::EDGERATIO)
        return "EdgeRatio";
    if (t == MeshQualityType::EQUIANGLESKEW)
        return "EquiAngleSkew";
    if (t == MeshQualityType::RADIUSEDGERATIO)
        return "RadiusEdgeRatio";
    if (t == MeshQualityType::SIZEDIFFERENCE)
        return "SizeDifference";
    return "none";
}

}