MeshLib::IO::Legacy::MeshIO Class Reference

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.
	~MeshIO () override=default
MeshLib::Mesh *	loadMeshFromFile (const std::string &file_name)
	Read mesh from file.
void	setMesh (const MeshLib::Mesh *mesh)
	Set mesh for writing.
Public Member Functions inherited from BaseLib::IO::Writer
	Writer ()
virtual	~Writer ()=default
std::string	writeToString ()
	Writes the object to a string.

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

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.

Constructor & Destructor Documentation

MeshIO()

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

default

Constructor.

~MeshIO()

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

overridedefault

Member Function Documentation

loadMeshFromFile()

MeshLib::Mesh * MeshLib::IO::Legacy::MeshIO::loadMeshFromFile

(

const std::string &

file_name

)

Read mesh from file.

Definition at line 277 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;
    std::getline(in, line_string);
 
    if (line_string.find("#FEM_MSH") != std::string::npos)  // OGS mesh file
    {
        std::vector<MeshLib::Node*> nodes;
        std::vector<MeshLib::Element*> elements;
        std::vector<int> materials;
 
        while (!in.eof())
        {
            std::getline(in, line_string);
 
            // check keywords
            if (line_string.find("#STOP") != std::string::npos)
            {
                break;
            }
            if (line_string.find("$NODES") != std::string::npos)
            {
                std::getline(in, line_string);
                BaseLib::trim(line_string);
                unsigned nNodes = atoi(line_string.c_str());
                for (unsigned i = 0; i < nNodes; ++i)
                {
                    std::getline(in, line_string);
                    std::stringstream iss(line_string);
                    unsigned idx;
                    double x;
                    double y;
                    double z;
                    iss >> idx >> x >> y >> z;
                    auto* node(new MeshLib::Node(x, y, z, idx));
                    nodes.push_back(node);
                    std::string s;
                    iss >> s;
                    if (s.find("$AREA") != std::string::npos)
                    {
                        double double_dummy;
                        iss >> double_dummy;
                    }
                }
            }
            else if (line_string.find("$ELEMENTS") != std::string::npos)
            {
                std::getline(in, line_string);
                BaseLib::trim(line_string);
                unsigned nElements = atoi(line_string.c_str());
                for (unsigned i = 0; i < nElements; ++i)
                {
                    std::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, true /* compute_element_neighbors */));
 
        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->assign(materials);
        }
        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(), BaseLib::trim(), and WARN().

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

setMesh()

void MeshLib::IO::Legacy::MeshIO::setMesh

(

const MeshLib::Mesh *

mesh

)

Set mesh for writing.

Definition at line 437 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 399 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, and WARN().

Member Data Documentation

_mesh

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

private

Definition at line 55 of file MeshIO.h.

{nullptr};

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