FileIO::GMSH Namespace Reference

Classes
class	GMSHAdaptiveMeshDensity
class	GMSHFixedMeshDensity
class	GMSHInterface
	Reads and writes GMSH-files to and from OGS data structures. More...
class	GMSHLine
class	GMSHLineLoop
class	GMSHMeshDensityStrategy
class	GMSHPoint
class	GMSHPolygonTree

Enumerations
enum class	MeshDensityAlgorithm { FixedMeshDensity , AdaptiveMeshDensity }

Functions
static std::ostream &	operator<< (std::ostream &os, std::vector< GMSHPoint * > const &points)
std::ostream &	operator<< (std::ostream &os, GMSHPoint const &p)
bool	isGMSHMeshFile (const std::string &fname)
void	readNodeIDs (std::ifstream &in, unsigned n_nodes, std::vector< unsigned > &node_ids, std::map< unsigned, unsigned > const &id_map)
template<typename ElementType >
std::pair< MeshLib::Element *, int >	createElement (std::ifstream &in, std::vector< MeshLib::Node * > const &nodes, int const mat_id, std::map< unsigned, unsigned > const &id_map)
template<>
std::pair< MeshLib::Element *, int >	createElement< MeshLib::Tri > (std::ifstream &in, std::vector< MeshLib::Node * > const &nodes, int const mat_id, std::map< unsigned, unsigned > const &id_map)
template<>
std::pair< MeshLib::Element *, int >	createElement< MeshLib::Tet10 > (std::ifstream &in, std::vector< MeshLib::Node * > const &nodes, int const mat_id, std::map< unsigned, unsigned > const &id_map)
template<>
std::pair< MeshLib::Element *, int >	createElement< MeshLib::Hex20 > (std::ifstream &in, std::vector< MeshLib::Node * > const &nodes, int const mat_id, std::map< unsigned, unsigned > const &id_map)
template<>
std::pair< MeshLib::Element *, int >	createElement< MeshLib::Prism15 > (std::ifstream &in, std::vector< MeshLib::Node * > const &nodes, int const mat_id, std::map< unsigned, unsigned > const &id_map)
template<>
std::pair< MeshLib::Element *, int >	createElement< MeshLib::Pyramid13 > (std::ifstream &in, std::vector< MeshLib::Node * > const &nodes, int const mat_id, std::map< unsigned, unsigned > const &id_map)
std::pair< MeshLib::Element *, int >	readElement (std::ifstream &in, std::vector< MeshLib::Node * > const &nodes, std::map< unsigned, unsigned > const &id_map, bool const is_created_with_gmsh2)
MeshLib::Mesh *	readGMSHMesh (std::string const &fname, bool const is_created_with_gmsh2)

Enumeration Type Documentation

MeshDensityAlgorithm

enum class FileIO::GMSH::MeshDensityAlgorithm

strong

Enumerator
FixedMeshDensity	set the parameter with a fixed value
AdaptiveMeshDensity	computing the mesh density employing a QuadTree

Definition at line 38 of file GMSHInterface.h.

                                {
    FixedMeshDensity, 
    AdaptiveMeshDensity 
};

Function Documentation

createElement()

template<typename ElementType >

std::pair< MeshLib::Element *, int > FileIO::GMSH::createElement	(	std::ifstream &	in,
		std::vector< MeshLib::Node * > const &	nodes,
		int const	mat_id,
		std::map< unsigned, unsigned > const &	id_map )

Definition at line 76 of file GmshReader.cpp.

{
    std::vector<unsigned> node_ids;
    readNodeIDs(in, ElementType::n_all_nodes, node_ids, id_map);
 
    std::array<MeshLib::Node*, ElementType::n_all_nodes> element_nodes;
 
    std::transform(begin(node_ids), end(node_ids), begin(element_nodes),
                   [&nodes](auto const id) { return nodes[id]; });
 
    return std::make_pair(new ElementType(element_nodes), mat_id);
}

References readNodeIDs().

Referenced by readElement().

createElement< MeshLib::Hex20 >()

template<>

std::pair< MeshLib::Element *, int > FileIO::GMSH::createElement< MeshLib::Hex20 >	(	std::ifstream &	in,
		std::vector< MeshLib::Node * > const &	nodes,
		int const	mat_id,
		std::map< unsigned, unsigned > const &	id_map )

Definition at line 76 of file GmshReader.cpp.

{
    std::vector<unsigned> node_ids;
    readNodeIDs(in, MeshLib::Hex20::n_all_nodes, node_ids, id_map);
 
    std::array<MeshLib::Node*, MeshLib::Hex20::n_all_nodes> element_nodes;
 
    constexpr std::array node_order = {0,  1, 2,  3,  4,  5,  6,  7,  8,  11,
                                       13, 9, 16, 18, 19, 17, 10, 12, 14, 15};
 
    std::transform(begin(node_order), end(node_order), begin(element_nodes),
                   [&node_ids, &nodes](auto const id)
                   { return nodes[node_ids[id]]; });
 
    return std::make_pair(new MeshLib::Hex20(element_nodes), mat_id);
}

Referenced by readElement().

createElement< MeshLib::Prism15 >()

template<>

std::pair< MeshLib::Element *, int > FileIO::GMSH::createElement< MeshLib::Prism15 >	(	std::ifstream &	in,
		std::vector< MeshLib::Node * > const &	nodes,
		int const	mat_id,
		std::map< unsigned, unsigned > const &	id_map )

Definition at line 76 of file GmshReader.cpp.

{
    std::vector<unsigned> node_ids;
    readNodeIDs(in, MeshLib::Prism15::n_all_nodes, node_ids, id_map);
 
    std::array<MeshLib::Node*, MeshLib::Prism15::n_all_nodes> element_nodes;
 
    constexpr std::array node_order = {0, 1,  2,  3,  4, 5,  6, 9,
                                       7, 12, 14, 13, 8, 10, 11};
 
    std::transform(begin(node_order), end(node_order), begin(element_nodes),
                   [&node_ids, &nodes](auto const id)
                   { return nodes[node_ids[id]]; });
 
    return std::make_pair(new MeshLib::Prism15(element_nodes), mat_id);
}

Referenced by readElement().

createElement< MeshLib::Pyramid13 >()

template<>

std::pair< MeshLib::Element *, int > FileIO::GMSH::createElement< MeshLib::Pyramid13 >	(	std::ifstream &	in,
		std::vector< MeshLib::Node * > const &	nodes,
		int const	mat_id,
		std::map< unsigned, unsigned > const &	id_map )

Definition at line 76 of file GmshReader.cpp.

{
    std::vector<unsigned> node_ids;
    readNodeIDs(in, MeshLib::Pyramid13::n_all_nodes, node_ids, id_map);
    std::array<MeshLib::Node*, MeshLib::Pyramid13::n_all_nodes> element_nodes;
 
    constexpr std::array node_order = {0,  1, 2, 3, 4,  5, 8,
                                       10, 6, 7, 9, 11, 12};
 
    std::transform(begin(node_order), end(node_order), begin(element_nodes),
                   [&node_ids, &nodes](auto const id)
                   { return nodes[node_ids[id]]; });
 
    return std::make_pair(new MeshLib::Pyramid13(element_nodes), mat_id);
}

Referenced by readElement().

createElement< MeshLib::Tet10 >()

template<>

std::pair< MeshLib::Element *, int > FileIO::GMSH::createElement< MeshLib::Tet10 >	(	std::ifstream &	in,
		std::vector< MeshLib::Node * > const &	nodes,
		int const	mat_id,
		std::map< unsigned, unsigned > const &	id_map )

Definition at line 76 of file GmshReader.cpp.

{
    std::vector<unsigned> node_ids;
    readNodeIDs(in, MeshLib::Tet10::n_all_nodes, node_ids, id_map);
 
    std::swap(node_ids[8], node_ids[9]);
 
    std::array<MeshLib::Node*, MeshLib::Tet10::n_all_nodes> element_nodes;
 
    std::transform(begin(node_ids), end(node_ids), begin(element_nodes),
                   [&nodes](auto const id) { return nodes[id]; });
 
    return std::make_pair(new MeshLib::Tet10(element_nodes), mat_id);
}

Referenced by readElement().

createElement< MeshLib::Tri >()

template<>

std::pair< MeshLib::Element *, int > FileIO::GMSH::createElement< MeshLib::Tri >	(	std::ifstream &	in,
		std::vector< MeshLib::Node * > const &	nodes,
		int const	mat_id,
		std::map< unsigned, unsigned > const &	id_map )

Definition at line 76 of file GmshReader.cpp.

{
    std::vector<unsigned> node_ids;
    readNodeIDs(in, 3, node_ids, id_map);
 
    std::array<MeshLib::Node*, 3> element_nodes;
 
    std::transform(std::rbegin(node_ids), std::rend(node_ids),
                   begin(element_nodes),
                   [&nodes](auto const id) { return nodes[id]; });
 
    return std::make_pair(new MeshLib::Tri(element_nodes), mat_id);
}

Referenced by readElement().

isGMSHMeshFile()

bool FileIO::GMSH::isGMSHMeshFile

(

const std::string &

fname

)

checks if there is a GMSH mesh file header

Parameters

fname

the file name of the mesh (including the path)

Returns

true, if the file seems to be a valid GMSH file, else false

Definition at line 37 of file GmshReader.cpp.

{
    std::ifstream input(fname.c_str());
 
    if (!input)
    {
        ERR("isGMSHMeshFile(): Could not open file {:s}.", fname);
        return false;
    }
 
    std::string header_first_line;
    input >> header_first_line;
    if (header_first_line.find("$MeshFormat") != std::string::npos)
    {
        // read version
        std::string version;
        std::getline(input, version);
        std::getline(input, version);
        INFO("isGMSHMeshFile(): Found GMSH mesh file version: {:s}.", version);
        input.close();
        return true;
    }
 
    return false;
}

References ERR(), and INFO().

Referenced by MainWindow::loadFile().

operator<<() [1/2]

std::ostream & FileIO::GMSH::operator<<	(	std::ostream &	os,
		GMSHPoint const &	p )

overload the output operator for class GMSHPoint

Definition at line 41 of file GMSHPoint.cpp.

{
    p.write(os);
    return os;
}

operator<<() [2/2]

static std::ostream & FileIO::GMSH::operator<< ( std::ostream & os, std::vector< GMSHPoint * > const & points )

static

Definition at line 37 of file GMSHInterface.cpp.

{
    for (auto const* const point : points)
    {
        if (point)
        {
            os << *point << "\n";
        }
    }
    return os;
}

readElement()

std::pair< MeshLib::Element *, int > FileIO::GMSH::readElement	(	std::ifstream &	in,
		std::vector< MeshLib::Node * > const &	nodes,
		std::map< unsigned, unsigned > const &	id_map,
		bool const	is_created_with_gmsh2 )

Definition at line 185 of file GmshReader.cpp.

{
    unsigned idx;
    unsigned type;
    unsigned n_tags;
    unsigned dummy;
    int mat_id;
 
    // The element format is structured like this:
    // Gmsh version 4:
    // element-id element-type n-tags physical-entity elementary entity node-ids
    // Gmsh version 2:
    // element-id element-type n-tags  elementary physical-entity entity
    // node-ids
 
    in >> idx >> type >> n_tags;
 
    if (!is_created_with_gmsh2)
    {
        in >> mat_id >> dummy;
    }
    else  // for meshes created by using Gmsh version 2
    {
        in >> dummy >> mat_id;
    }
 
    switch (type)
    {
        case 1:
        {
            return createElement<MeshLib::Line>(in, nodes, mat_id, id_map);
        }
        case 2:
        {
            return createElement<MeshLib::Tri>(in, nodes, mat_id, id_map);
        }
        case 3:
        {
            return createElement<MeshLib::Quad>(in, nodes, mat_id, id_map);
        }
        case 4:
        {
            return createElement<MeshLib::Tet>(in, nodes, mat_id, id_map);
        }
        case 5:
        {
            return createElement<MeshLib::Hex>(in, nodes, mat_id, id_map);
        }
        case 6:
        {
            return createElement<MeshLib::Prism>(in, nodes, mat_id, id_map);
        }
        case 7:
        {
            return createElement<MeshLib::Pyramid>(in, nodes, mat_id, id_map);
        }
        case 8:  // 3-node second order line.
        {
            return createElement<MeshLib::Line3>(in, nodes, mat_id, id_map);
        }
        case 9:  // 6-node second order triangle.
        {
            return createElement<MeshLib::Tri6>(in, nodes, mat_id, id_map);
        }
        case 10:  // 9-node second order quadrangle.
        {
            return createElement<MeshLib::Quad9>(in, nodes, mat_id, id_map);
        }
        case 11:  // 10-node second order tetrahedron.
        {
            return createElement<MeshLib::Tet10>(in, nodes, mat_id, id_map);
        }
        case 16:  // 8-node second order quadrangle.
        {
            return createElement<MeshLib::Quad8>(in, nodes, mat_id, id_map);
        }
        case 17:  // 20-node second order hexahedron.
        {
            return createElement<MeshLib::Hex20>(in, nodes, mat_id, id_map);
        }
        case 18:  // 15-node second order prism.
        {
            return createElement<MeshLib::Prism15>(in, nodes, mat_id, id_map);
        }
        case 19:  // 13-node second order pyramid.
        {
            return createElement<MeshLib::Pyramid13>(in, nodes, mat_id, id_map);
        }
        case 15:
            in >> dummy;  // skip rest of line
            break;
        default:
            WARN("readGMSHMesh(): Unknown element type {:d}.", type);
            break;
    }
    return std::make_pair(nullptr, -1);
}

References createElement(), createElement< MeshLib::Hex20 >(), createElement< MeshLib::Prism15 >(), createElement< MeshLib::Pyramid13 >(), createElement< MeshLib::Tet10 >(), createElement< MeshLib::Tri >(), and WARN().

Referenced by readGMSHMesh().

readGMSHMesh()

MeshLib::Mesh * FileIO::GMSH::readGMSHMesh	(	std::string const &	fname,
		bool const	is_created_with_gmsh2 = false )

reads a mesh created by GMSH - this implementation is based on the former function GMSH2MSH

Parameters

fname	the file name of the mesh (including the path)
is_created_with_gmsh2	An indicator for the mesh created by using Gmsh version 2.

Returns

Definition at line 286 of file GmshReader.cpp.

{
    if (!is_created_with_gmsh2)
    {
        WARN(
            "If the mesh is generated with Gmsh version 2 and it is saved"
            " (or exported) as \"Version 2 ASCII\" format, the flag"
            " --gmsh2_physical_id must be used for a correct conversion from "
            "physical id to MaterialIDs.");
    }
 
    std::string line;
    std::ifstream in(fname.c_str(), std::ios::in);
    if (!in.is_open())
    {
        WARN("readGMSHMesh() - Could not open file {:s}.", fname);
        return nullptr;
    }
 
    std::getline(in, line);  // $MeshFormat keyword
    if (line.find("$MeshFormat") == std::string::npos)
    {
        in.close();
        WARN("No GMSH file format recognized.");
        return nullptr;
    }
 
    std::getline(in, line);  // version-number file-type data-size
    if (line.substr(0, 3) != "2.2")
    {
        WARN("Wrong gmsh file format version '{:s}'.", line.substr(0, 3));
        return nullptr;
    }
 
    if (line[4] != '0')
    {
        WARN("Currently reading gmsh binary file type is not supported.");
        return nullptr;
    }
    std::getline(in, line);  //$EndMeshFormat
 
    std::vector<MeshLib::Node*> nodes;
    std::vector<MeshLib::Element*> elements;
    std::vector<int> materials;
    std::map<unsigned, unsigned> id_map;
    while (line.find("$EndElements") == std::string::npos)
    {
        // Node data
        std::getline(in, line);  //$Nodes Keywords
        if (line.find("$Nodes") != std::string::npos)
        {
            std::size_t n_nodes(0);
            long id;
            double x;
            double y;
            double z;
            in >> n_nodes >> std::ws;
            nodes.resize(n_nodes);
            for (std::size_t i = 0; i < n_nodes; i++)
            {
                in >> id >> x >> y >> z >> std::ws;
                id_map.insert(std::map<unsigned, unsigned>::value_type(id, i));
                nodes[i] = new MeshLib::Node(x, y, z, id);
            }
            std::getline(in, line);  // End Node keyword $EndNodes
        }
 
        // Element data
        if (line.find("$Elements") != std::string::npos)
        {
            std::size_t n_elements(0);
            if (!(in >> n_elements >> std::ws))
            {  // number-of-elements
                ERR("Read GMSH mesh does not contain any elements");
            }
            elements.reserve(n_elements);
            materials.reserve(n_elements);
            for (std::size_t i = 0; i < n_elements; i++)
            {
                MeshLib::Element* elem(nullptr);
                int mat_id(0);
                std::tie(elem, mat_id) =
                    readElement(in, nodes, id_map, is_created_with_gmsh2);
 
                if (elem)
                {
                    elements.push_back(elem);
                    materials.push_back(mat_id);
                }
            }
            std::getline(in, line);  // END keyword
        }
 
        if (line.find("PhysicalNames") != std::string::npos)
        {
            std::size_t n_lines(0);
            in >> n_lines >> std::ws;  // number-of-lines
            for (std::size_t i = 0; i < n_lines; i++)
            {
                std::getline(in, line);
            }
            std::getline(in, line);  // END keyword
        }
    }
    in.close();
    if (elements.empty())
    {
        for (auto& node : nodes)
        {
            delete node;
        }
        return nullptr;
    }
 
    MeshLib::Mesh* mesh(new MeshLib::Mesh(
        BaseLib::extractBaseNameWithoutExtension(fname), 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->insert(material_ids->end(), materials.cbegin(),
                             materials.cend());
    }
 
    MeshToolsLib::ElementValueModification::condense(*mesh);
 
    INFO("\t... finished.");
    INFO("Nr. Nodes: {:d}.", nodes.size());
    INFO("Nr. Elements: {:d}.", elements.size());
 
    return mesh;
}

References MeshLib::Cell, MeshToolsLib::ElementValueModification::condense(), MeshLib::Properties::createNewPropertyVector(), ERR(), BaseLib::extractBaseNameWithoutExtension(), MeshLib::Mesh::getProperties(), INFO(), MeshLib::Node, readElement(), and WARN().

Referenced by generateMesh(), MainWindow::loadFile(), and main().

readNodeIDs()

void FileIO::GMSH::readNodeIDs	(	std::ifstream &	in,
		unsigned	n_nodes,
		std::vector< unsigned > &	node_ids,
		std::map< unsigned, unsigned > const &	id_map )

Definition at line 63 of file GmshReader.cpp.

{
    unsigned idx;
    for (unsigned i = 0; i < n_nodes; i++)
    {
        in >> idx;
        node_ids.push_back(id_map.at(idx));
    }
}

Referenced by createElement().