anonymous_namespace{generateStructuredMesh.cpp} Namespace Reference

Classes
struct	BoundarySide

Functions
void	extract1DBoundaryMeshes (MeshLib::Mesh const &mesh, MathLib::Point3d const &origin, std::vector< double > const &length, std::string const &base)
void	extract2D3DBoundaryMeshes (MeshLib::Mesh const &mesh, unsigned dim, MathLib::Point3d const &origin, std::vector< double > const &length, std::string const &base)

Function Documentation

extract1DBoundaryMeshes()

void anonymous_namespace{generateStructuredMesh.cpp}::extract1DBoundaryMeshes	(	MeshLib::Mesh const &	mesh,
		MathLib::Point3d const &	origin,
		std::vector< double > const &	length,
		std::string const &	base )

Extract and write 1D boundary point meshes (left and right endpoints).

Parameters

mesh	The 1D line mesh
origin	The mesh origin point
length	The domain lengths
base	The base filename (without extension) for output

Definition at line 48 of file generateStructuredMesh.cpp.

{
    auto const eps = std::numeric_limits<double>::epsilon() *
                     *std::max_element(length.begin(), length.end()) * 100;
 
    std::array<BoundarySide, 2> const sides{
        {{"left", 0, origin[0]}, {"right", 0, origin[0] + length[0]}}};
 
    auto const& nodes = mesh.getNodes();
    for (auto const& side : sides)
    {
        auto const it =
            ranges::find_if(nodes, [&](auto const* n)
                            { return std::abs((*n)[0] - side.value) <= eps; });
 
        if (it == nodes.end())
        {
            continue;
        }
 
        auto* node = *it;
        auto* new_node = new MeshLib::Node(*node);
        std::vector<MeshLib::Node*> side_nodes{new_node};
        std::vector<MeshLib::Element*> side_elements{
            new MeshLib::Point({new_node})};
 
        MeshLib::Mesh side_mesh(side.name, side_nodes, side_elements);
 
        std::array<std::size_t, 1> const bulk_node_id{node->getID()};
        MeshLib::addPropertyToMesh<std::size_t>(
            side_mesh, MeshLib::getBulkIDString(MeshLib::MeshItemType::Node),
            MeshLib::MeshItemType::Node, 1, std::span{bulk_node_id});
 
        if (MeshLib::IO::writeMeshToFile(
                side_mesh,
                std::filesystem::path(base + "_" + side.name + ".vtu")) != 0)
        {
            ERR("Could not write boundary mesh '{:s}'.", side.name);
            continue;
        }
        INFO("Boundary mesh '{}' written.", side.name);
    }
}

References MeshLib::addPropertyToMesh(), ERR(), MeshLib::getBulkIDString(), MeshLib::Mesh::getNodes(), INFO(), MeshLib::Node, and MeshLib::IO::writeMeshToFile().

Referenced by main().

extract2D3DBoundaryMeshes()

void anonymous_namespace{generateStructuredMesh.cpp}::extract2D3DBoundaryMeshes	(	MeshLib::Mesh const &	mesh,
		unsigned	dim,
		MathLib::Point3d const &	origin,
		std::vector< double > const &	length,
		std::string const &	base )

Extract and write 2D/3D boundary meshes (left, right, bottom, top, and optionally front, back).

Parameters

mesh	The 2D or 3D mesh
dim	The mesh dimension (2 or 3)
origin	The mesh origin point
length	The domain lengths
base	The base filename (without extension) for output

Definition at line 102 of file generateStructuredMesh.cpp.

{
    auto const eps = std::numeric_limits<double>::epsilon() *
                     *std::max_element(length.begin(), length.end()) * 100;
 
    auto boundary_mesh =
        MeshToolsLib::BoundaryExtraction::getBoundaryElementsAsMesh(
            mesh, MeshLib::getBulkIDString(MeshLib::MeshItemType::Node),
            MeshLib::getBulkIDString(MeshLib::MeshItemType::Cell),
            MeshLib::getBulkIDString(MeshLib::MeshItemType::Face));
 
    std::vector<BoundarySide> sides{{"left", 0, origin[0]},
                                    {"right", 0, origin[0] + length[0]},
                                    {"bottom", 1, origin[1]},
                                    {"top", 1, origin[1] + length[1]}};
 
    if (dim == 3)
    {
        sides.push_back({"front", 2, origin[2]});
        sides.push_back({"back", 2, origin[2] + length[2]});
    }
 
    for (auto const& side : sides)
    {
        auto const node_on_side = [&](auto const node_id)
        {
            auto const* node = boundary_mesh->getNode(node_id);
            return std::abs((*node)[side.axis] - side.value) <= eps;
        };
        auto const element_not_on_side = [&](auto const* elem)
        {
            return !ranges::all_of(elem->nodes() | MeshLib::views::ids,
                                   node_on_side);
        };
        auto const remove_ids = boundary_mesh->getElements() |
                                ranges::views::filter(element_not_on_side) |
                                MeshLib::views::ids | ranges::to<std::vector>;
 
        std::unique_ptr<MeshLib::Mesh> side_mesh(MeshToolsLib::removeElements(
            *boundary_mesh, remove_ids, side.name));
 
        if (side_mesh && side_mesh->getNumberOfElements() > 0)
        {
            if (MeshLib::IO::writeMeshToFile(
                    *side_mesh,
                    std::filesystem::path(base + "_" + side.name + ".vtu")) !=
                0)
            {
                ERR("Could not write boundary mesh '{:s}'.", side.name);
                continue;
            }
            INFO("Boundary mesh '{}' written: {:d} nodes, {:d} elements.",
                 side.name, side_mesh->getNumberOfNodes(),
                 side_mesh->getNumberOfElements());
        }
    }
}

References MeshLib::Cell, ERR(), MeshLib::Face, MeshToolsLib::BoundaryExtraction::getBoundaryElementsAsMesh(), MeshLib::getBulkIDString(), MeshLib::views::ids, INFO(), MeshLib::Node, MeshToolsLib::removeElements(), and MeshLib::IO::writeMeshToFile().

Referenced by main().