lib_mesh.hpp

Go to the documentation of this file.

 
#ifndef NIHU_LIB_MESH_HPP_INCLUDED
#define NIHU_LIB_MESH_HPP_INCLUDED
 
#include "../core/mesh.hpp"
#include "lib_element.hpp"
 
namespace NiHu
{
 
enum orientation {
    inward,
    outward
};
 
 
template <class ElemTag = NiHu::line_1_tag>
NiHu::mesh<tmp::vector<typename NiHu::tag2type<ElemTag>::type > > 
create_circle_mesh(
    double r,
    size_t nElem,
    orientation ori = outward,
    ElemTag tag = ElemTag())
{
    using namespace boost::math::double_constants;
    
    typedef ElemTag tag_t;
    typedef typename NiHu::tag2type<tag_t>::type elem_t;
    // the number of nodes per element
    static size_t const M = elem_t::num_nodes;
 
    // the total number of nodes
    size_t nNodes = (M-1) * nElem;
    // create nodal locations
    Eigen::Matrix<double, Eigen::Dynamic, 2> nodes(nNodes, 2);
    for (size_t i = 0; i < nNodes; ++i) {
        double phi = i*two_pi/nNodes;
        nodes.row(i) << r * cos(phi), r * sin(phi);
    }
 
    // create matrix of elements
    Eigen::Matrix<unsigned, Eigen::Dynamic, M+1> elements(nElem, M + 1);
    for (size_t i = 0; i < nElem; ++i) {
        elements(i,0) = elem_t::id;
        for (size_t j = 0; j < M; ++j)
            if (ori == outward)
                elements(i,j+1) = (i * (M-1) + j) % nNodes;
            else
                elements(i,M - j) = (i * (M-1) + j) % nNodes;
    }
 
    // create the mesh
    return NiHu::create_mesh(nodes, elements, tag);
} // function create_circle_mesh
 
 
template <class ElemTag = NiHu::line_1_tag>
NiHu::mesh<tmp::vector<typename NiHu::tag2type<ElemTag>::type > >
create_rectangle_mesh(
    double Lx, double Ly,
    size_t nx, size_t ny,
    orientation ori = outward,
    ElemTag tag = ElemTag())
{
    typedef ElemTag tag_t;
    typedef typename NiHu::tag2type<tag_t>::type elem_t;
    // number of nodes per element
    static size_t const M = elem_t::num_nodes;
    // total number of elements
    size_t nElem = 2 * (nx + ny);
    // total number of nodes
    size_t nNodes = (M - 1) * nElem;
    Eigen::Matrix<double, Eigen::Dynamic, 2> nodes(nNodes, 2);
 
    // create nodal locations
    size_t k = 0;
    for (size_t i = 0; i < nx * (M - 1); ++i)
        nodes.row(k++) << Lx / (nx * (M - 1)) * i, 0.0;
    for (size_t i = 0; i < ny * (M - 1); ++i)
        nodes.row(k++) << Lx, Ly / (ny * (M - 1)) * i;
    for (size_t i = 0; i < nx * (M - 1); ++i)
        nodes.row(k++) << Lx - Lx / (nx * (M - 1)) * i, Ly;
    for (size_t i = 0; i < ny * (M - 1); ++i)
        nodes.row(k++) << 0.0, Ly - Ly / (ny * (M - 1)) * i;
 
    // create elements matrix
    Eigen::Matrix<unsigned, Eigen::Dynamic, M + 1> elements(nElem, M + 1);
    for (size_t i = 0; i < nElem; ++i) {
        elements(i, 0) = elem_t::id;
        for (size_t j = 0; j < M; ++j)
            if (ori == outward)
                elements(i, j + 1) = (i * (M-1) + j) % nNodes;
            else
                elements(i, M - j) = (i * (M-1) + j) % nNodes;
    }
 
    return NiHu::create_mesh(nodes, elements, tag);
} // end of function create_rectangle_mesh
 
 
} // end of namespace NiHu
 
#endif // NIHU_LIB_MESH_HPP_INCLUDED