MeshGenerator.h

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <functional>
#include <string>
#include <vector>
 
#include "BaseLib/Subdivision.h"
#include "MathLib/Point3d.h"
#include "MeshLib/Mesh.h"
 
namespace MeshLib
{
class Node;
 
namespace MeshGenerator
{
 
std::vector<MeshLib::Node*> generateRegularNodes(
    const std::vector<const std::vector<double>*> &vec_xyz_coords,
    const MathLib::Point3d& origin = MathLib::ORIGIN);
 
std::vector<MeshLib::Node*> generateRegularNodes(
    const std::vector<double> &vec_x_coords,
    const MathLib::Point3d& origin = MathLib::ORIGIN);
 
std::vector<MeshLib::Node*> generateRegularNodes(
    std::vector<double> &vec_x_coords,
    std::vector<double> &vec_y_coords,
    const MathLib::Point3d& origin = MathLib::ORIGIN);
 
std::vector<MeshLib::Node*> generateRegularNodes(
    std::vector<double> &vec_x_coords,
    std::vector<double> &vec_y_coords,
    std::vector<double> &vec_z_coords,
    const MathLib::Point3d& origin = MathLib::ORIGIN);
 
std::vector<MeshLib::Node*> generateRegularNodes(const std::array<unsigned,3> &n_cells,
                                                 const std::array<double,3> &cell_size,
                                                 const MathLib::Point3d& origin);
 
Mesh* generateLineMesh(const BaseLib::ISubdivision &div,
                       MathLib::Point3d const& origin = MathLib::ORIGIN,
                       std::string const& mesh_name = "mesh");
 
Mesh* generateLineMesh(const double length,
                       const std::size_t subdivision,
                       MathLib::Point3d const& origin = MathLib::ORIGIN,
                       std::string   const& mesh_name = "mesh");
 
Mesh* generateLineMesh(const unsigned n_cells,
                       const double   cell_size,
                       MathLib::Point3d const& origin = MathLib::ORIGIN,
                       std::string   const& mesh_name = "mesh");
 
Mesh* generateRegularQuadMesh(const BaseLib::ISubdivision &div_x,
                              const BaseLib::ISubdivision &div_y,
                              MathLib::Point3d const& origin = MathLib::ORIGIN,
                              std::string const& mesh_name = "mesh");
 
Mesh* generateRegularQuadMesh(const double length,
                              const std::size_t subdivision,
                              MathLib::Point3d const& origin = MathLib::ORIGIN,
                              std::string   const& mesh_name = "mesh");
 
Mesh* generateRegularQuadMesh(const double x_length,
                              const double y_length,
                              const std::size_t x_subdivision,
                              const std::size_t y_subdivision,
                              MathLib::Point3d const& origin = MathLib::ORIGIN,
                              std::string   const& mesh_name = "mesh");
 
Mesh* generateRegularQuadMesh(const unsigned n_x_cells,
                              const unsigned n_y_cells,
                              const double   cell_size,
                              MathLib::Point3d const& origin = MathLib::ORIGIN,
                              std::string   const& mesh_name = "mesh");
 
Mesh* generateRegularQuadMesh(const unsigned n_x_cells,
                              const unsigned n_y_cells,
                              const double   cell_size_x,
                              const double   cell_size_y,
                              MathLib::Point3d const& origin = MathLib::ORIGIN,
                              std::string   const& mesh_name = "mesh");
 
Mesh* generateRegularHexMesh(const BaseLib::ISubdivision &div_x,
                             const BaseLib::ISubdivision &div_y,
                             const BaseLib::ISubdivision &div_z,
                             MathLib::Point3d const& origin = MathLib::ORIGIN,
                             std::string const& mesh_name = "mesh");
 
Mesh* generateRegularHexMesh(const double length,
                             const std::size_t subdivision,
                             MathLib::Point3d const& origin = MathLib::ORIGIN,
                             std::string const& mesh_name = "mesh");
 
Mesh* generateRegularHexMesh(const double x_length,
                             const double y_length,
                             const double z_length,
                             const std::size_t x_subdivision,
                             const std::size_t y_subdivision,
                             const std::size_t z_subdivision,
                             MathLib::Point3d const& origin = MathLib::ORIGIN,
                             std::string   const& mesh_name = "mesh");
 
Mesh* generateRegularHexMesh(const unsigned n_x_cells,
                             const unsigned n_y_cells,
                             const unsigned n_z_cells,
                             const double   cell_size,
                             MathLib::Point3d const& origin = MathLib::ORIGIN,
                             std::string   const& mesh_name = "mesh");
 
Mesh* generateRegularHexMesh(const unsigned n_x_cells,
                             const unsigned n_y_cells,
                             const unsigned n_z_cells,
                             const double   cell_size_x,
                             const double   cell_size_y,
                             const double   cell_size_z,
                             MathLib::Point3d const& origin = MathLib::ORIGIN,
                             std::string   const& mesh_name = "mesh");
 
Mesh* generateRegularPyramidMesh(
    const BaseLib::ISubdivision& div_x,
    const BaseLib::ISubdivision& div_y,
    const BaseLib::ISubdivision& div_z,
    MathLib::Point3d const& origin = MathLib::ORIGIN,
    std::string const& mesh_name = "mesh");
 
Mesh* generateRegularTriMesh(const BaseLib::ISubdivision &div_x,
                             const BaseLib::ISubdivision &div_y,
                             MathLib::Point3d const& origin = MathLib::ORIGIN,
                             std::string const& mesh_name = "mesh");
 
Mesh* generateRegularTriMesh(const double length,
                              const std::size_t subdivision,
                              MathLib::Point3d const& origin = MathLib::ORIGIN,
                              std::string   const& mesh_name = "mesh");
 
Mesh* generateRegularTriMesh(const double x_length,
                             const double y_length,
                             const std::size_t x_subdivision,
                             const std::size_t y_subdivision,
                             MathLib::Point3d const& origin = MathLib::ORIGIN,
                             std::string   const& mesh_name = "mesh");
 
Mesh* generateRegularTriMesh(const unsigned n_x_cells,
                             const unsigned n_y_cells,
                             const double   cell_size,
                             MathLib::Point3d const& origin = MathLib::ORIGIN,
                             std::string   const& mesh_name = "mesh");
 
Mesh* generateRegularTriMesh(const unsigned n_x_cells,
                             const unsigned n_y_cells,
                             const double   cell_size_x,
                             const double   cell_size_y,
                             MathLib::Point3d const& origin = MathLib::ORIGIN,
                             std::string   const& mesh_name = "mesh");
 
Mesh* generateRegularPrismMesh(const double x_length,
                               const double y_length,
                               const double z_length,
                               const std::size_t x_subdivision,
                               const std::size_t y_subdivision,
                               const std::size_t z_subdivision,
                               MathLib::Point3d const& origin = MathLib::ORIGIN,
                               std::string   const& mesh_name = "mesh");
 
Mesh* generateRegularPrismMesh(const unsigned n_x_cells,
                               const unsigned n_y_cells,
                               const unsigned n_z_cells,
                               const double cell_size,
                               MathLib::Point3d const& origin = MathLib::ORIGIN,
                               std::string   const& mesh_name = "mesh");
 
Mesh* generateRegularPrismMesh(const unsigned n_x_cells,
                               const unsigned n_y_cells,
                               const unsigned n_z_cells,
                               const double   cell_size_x,
                               const double   cell_size_y,
                               const double   cell_size_z,
                               MathLib::Point3d const& origin = MathLib::ORIGIN,
                               std::string   const& mesh_name = "mesh");
 
Mesh* generateRegularTetMesh(const BaseLib::ISubdivision &div_x,
                             const BaseLib::ISubdivision &div_y,
                             const BaseLib::ISubdivision &div_z,
                             MathLib::Point3d const& origin = MathLib::ORIGIN,
                             std::string const& mesh_name = "mesh");
 
Mesh* generateRegularTetMesh(const double x_length,
                             const double y_length,
                             const double z_length,
                             const std::size_t x_subdivision,
                             const std::size_t y_subdivision,
                             const std::size_t z_subdivision,
                             MathLib::Point3d const& origin = MathLib::ORIGIN,
                             std::string   const& mesh_name = "mesh");
 
Mesh* generateRegularTetMesh(const unsigned n_x_cells,
                             const unsigned n_y_cells,
                             const unsigned n_z_cells,
                             const double   cell_size_x,
                             const double   cell_size_y,
                             const double   cell_size_z,
                             MathLib::Point3d const& origin = MathLib::ORIGIN,
                             std::string   const& mesh_name = "mesh");
 
MeshLib::Mesh*
createSurfaceMesh(std::string const& mesh_name,
    MathLib::Point3d const& ll, MathLib::Point3d const& ur,
    std::array<std::size_t, 2> const& n_steps,
    const std::function<double(double,double)>& f);
 
}  // namespace MeshGenerator
}  // namespace MeshLib