Detailed Description

Interface for handling mesh files from OGS-5 and below. (*.msh files)

Definition at line 36 of file MeshIO.h.

#include <MeshIO.h>

Inheritance diagram for MeshLib::IO::Legacy::MeshIO:

Collaboration diagram for MeshLib::IO::Legacy::MeshIO:

Public Member Functions
	MeshIO ()
	Constructor. More...

	~MeshIO () override=default

MeshLib::Mesh *	loadMeshFromFile (const std::string &file_name)
	Read mesh from file. More...

void	setMesh (const MeshLib::Mesh *mesh)
	Set mesh for writing. More...

Public Member Functions inherited from BaseLib::IO::Writer
	Writer ()

virtual	~Writer ()=default

std::string	writeToString ()
	Writes the object to a string. More...

Protected Member Functions
bool	write () override
	Write mesh to stream. More...

virtual bool	write ()=0
	Writes the object to the internal stream. This method must be implemented by a subclass. The implementation should return true on success, else false. More...

Private Member Functions
void	writeElements (std::vector< MeshLib::Element * > const &ele_vec, MeshLib::PropertyVector< int > const *const material_ids, std::ostream &out) const

MeshLib::Element *	readElement (std::istream &in, const std::vector< MeshLib::Node * > &nodes) const

Static Private Member Functions
static std::size_t	readMaterialID (std::istream &in)

static std::string	ElemType2StringOutput (const MeshLib::MeshElemType t)

Private Attributes
const MeshLib::Mesh *	_mesh {nullptr}

Additional Inherited Members
Protected Attributes inherited from BaseLib::IO::Writer
std::ostringstream	out
	The stream to write to. More...

Constructor & Destructor Documentation

◆ MeshIO()

MeshLib::IO::Legacy::MeshIO::MeshIO ( )

default

Constructor.

◆ ~MeshIO()

MeshLib::IO::Legacy::MeshIO::~MeshIO ( )

overridedefault

Member Function Documentation

◆ ElemType2StringOutput()

std::string MeshLib::IO::Legacy::MeshIO::ElemType2StringOutput ( const MeshLib::MeshElemType t )

staticprivate

Definition at line 407 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, MathLib::t, MeshLib::TETRAHEDRON, and MeshLib::TRIANGLE.

Referenced by writeElements().

◆ loadMeshFromFile()

MeshLib::Mesh * MeshLib::IO::Legacy::MeshIO::loadMeshFromFile ( const std::string & file_name )

Read mesh from file.

Definition at line 42 of file MeshIO.cpp.

{
    INFO("Reading OGS legacy mesh ... ");
 
    std::ifstream in(file_name.c_str(), std::ios::in);
    if (!in.is_open())
    {
        WARN("MeshIO::loadMeshFromFile() - Could not open file {:s}.",
             file_name);
        return nullptr;
    }
 
    std::string line_string;
    getline(in, line_string);
 
    std::vector<MeshLib::Node*> nodes;
    std::vector<MeshLib::Element*> elements;
    std::vector<std::size_t> materials;
 
    if (line_string.find("#FEM_MSH") != std::string::npos)  // OGS mesh file
    {
        while (!in.eof())
        {
            getline(in, line_string);
 
            // check keywords
            if (line_string.find("#STOP") != std::string::npos)
            {
                break;
            }
            if (line_string.find("$NODES") != std::string::npos)
            {
                double x;
                double y;
                double z;
                double double_dummy;
                unsigned idx;
                getline(in, line_string);
                BaseLib::trim(line_string);
                unsigned nNodes = atoi(line_string.c_str());
                std::string s;
                for (unsigned i = 0; i < nNodes; ++i)
                {
                    getline(in, line_string);
                    std::stringstream iss(line_string);
                    iss >> idx >> x >> y >> z;
                    auto* node(new MeshLib::Node(x, y, z, idx));
                    nodes.push_back(node);
                    iss >> s;
                    if (s.find("$AREA") != std::string::npos)
                    {
                        iss >> double_dummy;
                    }
                }
            }
            else if (line_string.find("$ELEMENTS") != std::string::npos)
            {
                getline(in, line_string);
                BaseLib::trim(line_string);
                unsigned nElements = atoi(line_string.c_str());
                for (unsigned i = 0; i < nElements; ++i)
                {
                    getline(in, line_string);
                    std::stringstream ss(line_string);
                    materials.push_back(readMaterialID(ss));
                    MeshLib::Element* elem(readElement(ss, nodes));
                    if (elem == nullptr)
                    {
                        ERR("Reading mesh element {:d} from file '{:s}' "
                            "failed.",
                            i, file_name);
                        // clean up the elements vector
                        std::for_each(elements.begin(), elements.end(),
                                      std::default_delete<MeshLib::Element>());
                        // clean up the nodes vector
                        std::for_each(nodes.begin(), nodes.end(),
                                      std::default_delete<MeshLib::Node>());
                        return nullptr;
                    }
                    elements.push_back(elem);
                }
            }
        }
 
        if (elements.empty())
        {
            ERR("MeshIO::loadMeshFromFile() - File did not contain element "
                "information.");
            for (auto& node : nodes)
            {
                delete node;
            }
            return nullptr;
        }
 
        MeshLib::Mesh* mesh(new MeshLib::Mesh(
            BaseLib::extractBaseNameWithoutExtension(file_name), nodes,
            elements));
 
        auto* const material_ids =
            mesh->getProperties().createNewPropertyVector<int>(
                "MaterialIDs", MeshLib::MeshItemType::Cell, 1);
        if (!material_ids)
        {
            WARN("Could not create PropertyVector for MaterialIDs in Mesh.");
        }
        else
        {
            material_ids->insert(material_ids->end(), materials.cbegin(),
                                 materials.cend());
        }
        INFO("\t... finished.");
        INFO("Nr. Nodes: {:d}.", nodes.size());
        INFO("Nr. Elements: {:d}.", elements.size());
 
        in.close();
        return mesh;
    }
 
    in.close();
    return nullptr;
}

References MeshLib::Cell, MeshLib::Properties::createNewPropertyVector(), ERR(), BaseLib::extractBaseNameWithoutExtension(), MeshLib::Mesh::getProperties(), INFO(), readElement(), readMaterialID(), MathLib::s, BaseLib::trim(), and WARN().

Referenced by OGSFileConverter::convertMSH2VTU(), and anonymous_namespace{readMeshFromFile.cpp}::readMeshFromFileSerial().

◆ readElement()

MeshLib::Element * MeshLib::IO::Legacy::MeshIO::readElement	(	std::istream &	in,
		const std::vector< MeshLib::Node * > &	nodes
	)		const

private

Definition at line 176 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.

Referenced by loadMeshFromFile().

◆ readMaterialID()

std::size_t MeshLib::IO::Legacy::MeshIO::readMaterialID ( std::istream & in )

staticprivate

Definition at line 165 of file MeshIO.cpp.

{
    unsigned index;
    unsigned material_id;
    if (!(in >> index >> material_id))
    {
        return std::numeric_limits<std::size_t>::max();
    }
    return material_id;
}

Referenced by loadMeshFromFile().

◆ setMesh()

void MeshLib::IO::Legacy::MeshIO::setMesh ( const MeshLib::Mesh * mesh )

Set mesh for writing.

Definition at line 364 of file MeshIO.cpp.

{
    _mesh = mesh;
}

References _mesh.

Referenced by SaveMeshDialog::accept(), OGSFileConverter::convertVTU2MSH(), main(), and MeshLib::IO::writeMeshToFile().

◆ write()

bool MeshLib::IO::Legacy::MeshIO::write ( )

overrideprotectedvirtual

Write mesh to stream.

Implements BaseLib::IO::Writer.

Definition at line 326 of file MeshIO.cpp.

{
    if (!_mesh)
    {
        WARN("MeshIO::write(): Cannot write: no mesh object specified.");
        return false;
    }
 
    out << "#FEM_MSH\n"
        << "$PCS_TYPE\n"
        << "  NO_PCS\n"
        << "$NODES\n"
        << "  ";
    const std::size_t n_nodes(_mesh->getNumberOfNodes());
    out << n_nodes << "\n";
    for (std::size_t i(0); i < n_nodes; ++i)
    {
        out << i << " " << *(_mesh->getNode(i)) << "\n";
    }
 
    out << "$ELEMENTS\n"
        << "  ";
 
    if (!_mesh->getProperties().existsPropertyVector<int>("MaterialIDs"))
    {
        writeElements(_mesh->getElements(), nullptr, out);
    }
    else
    {
        writeElements(
            _mesh->getElements(),
            _mesh->getProperties().getPropertyVector<int>("MaterialIDs"), out);
    }
    out << "#STOP\n";
 
    return true;
}

References _mesh, MeshLib::Properties::existsPropertyVector(), MeshLib::Mesh::getElements(), MeshLib::Mesh::getNode(), MeshLib::Mesh::getNumberOfNodes(), MeshLib::Mesh::getProperties(), MeshLib::Properties::getPropertyVector(), BaseLib::IO::Writer::out, WARN(), and writeElements().

◆ writeElements()

void MeshLib::IO::Legacy::MeshIO::writeElements	(	std::vector< MeshLib::Element * > const &	ele_vec,
		MeshLib::PropertyVector< int > const *const	material_ids,
		std::ostream &	out
	)		const

private

Definition at line 369 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(), OGS_FATAL, and BaseLib::IO::Writer::out.

Referenced by write().

Member Data Documentation

◆ _mesh

const MeshLib::Mesh* MeshLib::IO::Legacy::MeshIO::_mesh {nullptr}

private

Definition at line 63 of file MeshIO.h.

Referenced by setMesh(), and write().

The documentation for this class was generated from the following files:

MeshLib/IO/Legacy/MeshIO.h
MeshLib/IO/Legacy/MeshIO.cpp

Detailed Description

Public Member Functions

Protected Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Constructor & Destructor Documentation

◆ MeshIO()

◆ ~MeshIO()

Member Function Documentation

◆ ElemType2StringOutput()

◆ loadMeshFromFile()

◆ readElement()

◆ readMaterialID()

◆ setMesh()

◆ write()

◆ writeElements()

Member Data Documentation

◆ _mesh