TetGenInterface.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <vector>
 
// GeoLib
#include "GeoLib/GEOObjects.h"
#include "GeoLib/Point.h"
 
// forward declaration of class Node and Element
namespace MeshLib
{
class Node;
class Element;
class Mesh;
}  // namespace MeshLib
 
namespace FileIO
{
// clang-format off
// clang-format on
class TetGenInterface final
{
public:
    TetGenInterface();

    bool readTetGenGeometry(std::string const& geo_fname,
                            GeoLib::GEOObjects& geo_objects);

    MeshLib::Mesh* readTetGenMesh(std::string const& nodes_fname,
                                  std::string const& ele_fname);

    static bool writeTetGenSmesh(
        const std::string& file_name,
        const GeoLib::GEOObjects& geo_objects,
        const std::string& geo_name,
        const std::vector<GeoLib::Point>& attribute_points);

    bool writeTetGenSmesh(const std::string& file_name,
                          const MeshLib::Mesh& mesh,
                          std::vector<MeshLib::Node>& attribute_points) const;
 
private:
    std::size_t getNFacets(std::ifstream& input);

    bool parseSmeshFacets(std::ifstream& input,
                          std::vector<GeoLib::Surface*>& surfaces,
                          const std::vector<GeoLib::Point*>& points,
                          const std::vector<std::size_t>& pnt_id_map);

    bool readNodesFromStream(std::ifstream& ins,
                             std::vector<MeshLib::Node*>& nodes);

    static bool parseNodesFileHeader(std::string const& line,
                                     std::size_t& n_nodes,
                                     std::size_t& dim,
                                     std::size_t& n_attributes,
                                     bool& boundary_markers);
    bool parseNodes(std::ifstream& ins,
                    std::vector<MeshLib::Node*>& nodes,
                    std::size_t n_nodes,
                    std::size_t dim);

    bool readElementsFromStream(std::ifstream& ins,
                                std::vector<MeshLib::Element*>& elements,
                                std::vector<int>& materials,
                                const std::vector<MeshLib::Node*>& nodes) const;
    static bool parseElementsFileHeader(std::string& line,
                                        std::size_t& n_tets,
                                        std::size_t& n_nodes_per_tet,
                                        bool& region_attribute);
    bool parseElements(std::ifstream& ins,
                       std::vector<MeshLib::Element*>& elements,
                       std::vector<int>& materials,
                       const std::vector<MeshLib::Node*>& nodes,
                       std::size_t n_tets,
                       std::size_t n_nodes_per_tet,
                       bool region_attribute) const;

    void write2dElements(std::ofstream& out, const MeshLib::Mesh& mesh) const;

    void write3dElements(std::ofstream& out,
                         const MeshLib::Mesh& mesh,
                         std::vector<MeshLib::Node>& attribute_points) const;

    static void writeElementToFacets(std::ofstream& out,
                                     const MeshLib::Element& element,
                                     unsigned& element_count,
                                     std::string const& matId);

    bool _zero_based_idx{false};

    bool _boundary_markers{false};
};
}  // namespace FileIO