anonymous_namespace{MeshIO.cpp} Namespace Reference

Functions
int	readMaterialID (std::istream &in)
MeshLib::Element *	readElement (std::istream &in, const std::vector< MeshLib::Node * > &nodes)
std::string	ElemType2StringOutput (const MeshLib::MeshElemType t)
void	writeElements (std::vector< MeshLib::Element * > const &ele_vec, MeshLib::PropertyVector< int > const *const material_ids, std::ostream &out)

Function Documentation

ElemType2StringOutput()

std::string anonymous_namespace{MeshIO.cpp}::ElemType2StringOutput

(

const MeshLib::MeshElemType

t

)

Definition at line 187 of file MeshIO.cpp.

{
    if (t == MeshLib::MeshElemType::LINE)
    {
        return "line";
    }
    if (t == MeshLib::MeshElemType::QUAD)
    {
        return "quad";
    }
    if (t == MeshLib::MeshElemType::HEXAHEDRON)
    {
        return "hex";
    }
    if (t == MeshLib::MeshElemType::TRIANGLE)
    {
        return "tri";
    }
    if (t == MeshLib::MeshElemType::TETRAHEDRON)
    {
        return "tet";
    }
    if (t == MeshLib::MeshElemType::PRISM)
    {
        return "pris";
    }
    if (t == MeshLib::MeshElemType::PYRAMID)
    {
        return "pyra";
    }
    return "none";
}

References MeshLib::HEXAHEDRON, MeshLib::LINE, MeshLib::PRISM, MeshLib::PYRAMID, MeshLib::QUAD, MeshLib::TETRAHEDRON, and MeshLib::TRIANGLE.

Referenced by writeElements().

readElement()

MeshLib::Element * anonymous_namespace{MeshIO.cpp}::readElement	(	std::istream &	in,
		const std::vector< MeshLib::Node * > &	nodes )

Definition at line 37 of file MeshIO.cpp.

{
    std::string elem_type_str;
    MeshLib::MeshElemType elem_type(MeshLib::MeshElemType::INVALID);
 
    do
    {
        if (!(in >> elem_type_str))
        {
            return nullptr;
        }
        elem_type = MeshLib::String2MeshElemType(elem_type_str);
    } while (elem_type == MeshLib::MeshElemType::INVALID);
 
    auto* idx = new unsigned[8];
    MeshLib::Element* elem;
 
    switch (elem_type)
    {
        case MeshLib::MeshElemType::LINE:
        {
            for (int i = 0; i < 2; ++i)
            {
                if (!(in >> idx[i]))
                {
                    return nullptr;
                }
            }
            // edge_nodes array will be deleted from Line object
            auto** edge_nodes = new MeshLib::Node*[2];
            for (unsigned k(0); k < 2; ++k)
            {
                edge_nodes[k] = nodes[idx[k]];
            }
            elem = new MeshLib::Line(edge_nodes);
            break;
        }
        case MeshLib::MeshElemType::TRIANGLE:
        {
            for (int i = 0; i < 3; ++i)
            {
                if (!(in >> idx[i]))
                {
                    return nullptr;
                }
            }
            auto** tri_nodes = new MeshLib::Node*[3];
            for (unsigned k(0); k < 3; ++k)
            {
                tri_nodes[k] = nodes[idx[k]];
            }
            elem = new MeshLib::Tri(tri_nodes);
            break;
        }
        case MeshLib::MeshElemType::QUAD:
        {
            for (int i = 0; i < 4; ++i)
            {
                if (!(in >> idx[i]))
                {
                    return nullptr;
                }
            }
            auto** quad_nodes = new MeshLib::Node*[4];
            for (unsigned k(0); k < 4; ++k)
            {
                quad_nodes[k] = nodes[idx[k]];
            }
            elem = new MeshLib::Quad(quad_nodes);
            break;
        }
        case MeshLib::MeshElemType::TETRAHEDRON:
        {
            for (int i = 0; i < 4; ++i)
            {
                if (!(in >> idx[i]))
                {
                    return nullptr;
                }
            }
            auto** tet_nodes = new MeshLib::Node*[4];
            for (unsigned k(0); k < 4; ++k)
            {
                tet_nodes[k] = nodes[idx[k]];
            }
            elem = new MeshLib::Tet(tet_nodes);
            break;
        }
        case MeshLib::MeshElemType::HEXAHEDRON:
        {
            for (int i = 0; i < 8; ++i)
            {
                if (!(in >> idx[i]))
                {
                    return nullptr;
                }
            }
            auto** hex_nodes = new MeshLib::Node*[8];
            for (unsigned k(0); k < 8; ++k)
            {
                hex_nodes[k] = nodes[idx[k]];
            }
            elem = new MeshLib::Hex(hex_nodes);
            break;
        }
        case MeshLib::MeshElemType::PYRAMID:
        {
            for (int i = 0; i < 5; ++i)
            {
                if (!(in >> idx[i]))
                {
                    return nullptr;
                }
            }
            auto** pyramid_nodes = new MeshLib::Node*[5];
            for (unsigned k(0); k < 5; ++k)
            {
                pyramid_nodes[k] = nodes[idx[k]];
            }
            elem = new MeshLib::Pyramid(pyramid_nodes);
            break;
        }
        case MeshLib::MeshElemType::PRISM:
        {
            for (int i = 0; i < 6; ++i)
            {
                if (!(in >> idx[i]))
                {
                    return nullptr;
                }
            }
            auto** prism_nodes = new MeshLib::Node*[6];
            for (unsigned k(0); k < 6; ++k)
            {
                prism_nodes[k] = nodes[idx[k]];
            }
            elem = new MeshLib::Prism(prism_nodes);
            break;
        }
        default:
            elem = nullptr;
            break;
    }
 
    delete[] idx;
 
    return elem;
}

References MeshLib::HEXAHEDRON, MeshLib::INVALID, MeshLib::LINE, MeshLib::PRISM, MeshLib::PYRAMID, MeshLib::QUAD, MeshLib::String2MeshElemType(), MeshLib::TETRAHEDRON, and MeshLib::TRIANGLE.

readMaterialID()

int anonymous_namespace{MeshIO.cpp}::readMaterialID

(

std::istream &

in

)

Definition at line 21 of file MeshIO.cpp.

{
    unsigned index;
    unsigned material_id;
 
    if (!(in >> index >> material_id) ||
        material_id > static_cast<unsigned>(std::numeric_limits<int>::max()))
    {
        // If read incorrectly or the material_id is not safely convertible to
        // int.
        return std::numeric_limits<int>::max();
    }
    // Safe conversion was checked above.
    return static_cast<int>(material_id);
}

writeElements()

void anonymous_namespace{MeshIO.cpp}::writeElements	(	std::vector< MeshLib::Element * > const &	ele_vec,
		MeshLib::PropertyVector< int > const *const	material_ids,
		std::ostream &	out )

Definition at line 220 of file MeshIO.cpp.

{
    const std::size_t ele_vector_size(ele_vec.size());
 
    out << ele_vector_size << "\n";
    for (std::size_t i(0); i < ele_vector_size; ++i)
    {
        auto const& element = *ele_vec[i];
        if (element.getNumberOfBaseNodes() != element.getNumberOfNodes())
        {
            OGS_FATAL(
                "Found high order element in the mesh that is not required by "
                "OGS 5 input. High order elements are generated in OGS 5 on "
                "demand.");
        }
 
        out << i << " ";
        if (!material_ids)
        {
            out << "0 ";
        }
        else
        {
            out << (*material_ids)[i] << " ";
        }
        out << ElemType2StringOutput(element.getGeomType()) << " ";
        unsigned nElemNodes(element.getNumberOfBaseNodes());
        for (std::size_t j = 0; j < nElemNodes; ++j)
        {
            out << element.getNode(j)->getID() << " ";
        }
        out << "\n";
    }
}

References ElemType2StringOutput(), and OGS_FATAL.