mesh.hpp

Go to the documentation of this file.

// This file is a part of NiHu, a C++ BEM template library.
//
// Copyright (C) 2012-2014  Peter Fiala <fiala@hit.bme.hu>
// Copyright (C) 2012-2014  Peter Rucz <rucz@hit.bme.hu>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
#ifndef NIHU_MESH_HPP_INCLUDED
#define NIHU_MESH_HPP_INCLUDED
 
#include "../util/crtp_base.hpp"
#include "../util/eigen_utils.hpp"
#include "../util/type2tag.hpp"
 
#include "../tmp/integer.hpp"
#include "../tmp/sequence.hpp"
#include "../tmp/algorithm.hpp"
#include "../tmp/control.hpp"
#include "../tmp/vector.hpp"
 
#include "element.hpp"
 
namespace NiHu
{
 
template <class ElemType>
struct mesh_elem_iterator_t
{
    typedef typename eigen_std_vector<ElemType>::type::const_iterator type;
};
 
 
template <class xType>
class field_points
{
public:
    typedef xType x_t; 
    static unsigned const nDim = x_t::SizeAtCompileTime; 
    typedef typename eigen_std_vector<x_t>::type::const_iterator iterator_t;    
    void add_point(x_t const &p)
    {
        points.push_back(p);
    }
 
    size_t get_num_points() const
    {
        return points.size();
    }
 
protected:
    typename eigen_std_vector<x_t>::type points;    
};
 
template <class ElemTypeVector>
struct first_elements_x_type
{
    typedef typename tmp::deref<
        typename tmp::begin<ElemTypeVector>::type
    >::type::x_t type;
};
 
 
template <class Derived>
class mesh_base
{
public:
    NIHU_CRTP_HELPERS
};
 
 
template <class ElemTypeVector>
class mesh
    : public mesh_base<mesh<ElemTypeVector>>
    , public field_points<typename first_elements_x_type<ElemTypeVector>::type>
{
public:
    typedef ElemTypeVector elem_type_vector_t;
 
    typedef field_points<typename first_elements_x_type<ElemTypeVector>::type> base_t;
 
    static unsigned const nDim = base_t::nDim;
 
    typedef typename tmp::inherit<
        typename tmp::transform<
            elem_type_vector_t,
            tmp::inserter<
                typename tmp::empty<elem_type_vector_t>::type,
                tmp::push_back<tmp::_1,tmp::_2>
            >,
            eigen_std_vector<tmp::_1>
        >::type
    >::type elem_container_t;
 
    typedef typename base_t::x_t x_t;
 
    typedef typename x_t::Scalar scalar_t;
 
    template <class ElemType>
    struct elem_iterator_t : mesh_elem_iterator_t<ElemType> {};
 
 
protected:
    template <class elem_t>
    struct elem_adder { struct type {
        bool operator() (unsigned const input[], mesh &m)
        {
            if (input[0] == elem_t::id)
            {
                // construct element
                typename elem_t::nodes_t nodes;
                typename elem_t::coords_t coords;
                for (unsigned i = 0; i < elem_t::num_nodes; ++i)
                {
                    nodes[i] = input[i+1];
                    coords.col(i) = m.points[nodes[i]];
                }
                m.push_element(elem_t(coords, m.m_num_elements++, nodes));
                return true;
            }
            return false;
        }
    };};
 
public:
    mesh() : m_num_elements(0)
    {
    }
 
    template <class node_t, class elem_t>
    mesh(node_t const &nodes, elem_t const &elements) : m_num_elements(0)
    {
        unsigned const N_MAX_ELEM = 1+9;
 
        for (unsigned i = 0; i < unsigned(nodes.rows()); ++i)
        {
            double c[nDim];
            for (unsigned j = 0; j < nDim; ++j)
                c[j] = nodes(i,j);
            add_node(c);
        }
        for (unsigned i = 0; i < unsigned(elements.rows()); ++i)
        {
            unsigned e[N_MAX_ELEM] = {0};
            for (unsigned j = 0; j < unsigned(elements.cols()); ++j)
                e[j] = unsigned(elements(i,j));
            add_elem(e);
        }
    }
    
    template <class ElemType>
    typename elem_iterator_t<ElemType>::type begin() const
    {
        return m_elements.eigen_std_vector<ElemType>::type::begin();
    }
 
    template <class ElemType>
    typename elem_iterator_t<ElemType>::type end() const
    {
        return m_elements.eigen_std_vector<ElemType>::type::end();
    }
 
    template <class ElemType>
    ElemType const &get_elem(size_t i) const 
    {
        return m_elements.eigen_std_vector<ElemType>::type::operator[](i);
    }
 
    bool add_elem(unsigned const input[])
    {
        return tmp::call_until<
            elem_type_vector_t,
            elem_adder<tmp::_1>,
            unsigned const*,
            mesh &
        >(input, *this);
    }
 
    void add_node(scalar_t input[])
    {
        x_t c;
        for (unsigned i = 0; i < nDim; ++i)
            c[i] = input[i];
        this->add_point(c);
    }
 
    template <class elem_t>
    elem_t const &push_element(element_base<elem_t> const &e)
    {
        m_elements.eigen_std_vector<elem_t>::type::push_back(e.derived());
        return *(m_elements.eigen_std_vector<elem_t>::type::rbegin());
    }
 
    unsigned get_num_elements() const
    {
        return m_num_elements;
    }
 
protected:
    elem_container_t m_elements;    
    unsigned m_num_elements;    
};
 
 
template <class nodes_t, class elements_t, class...Args>
mesh<tmp::vector<typename tag2type<Args>::type...> >
    create_mesh(nodes_t const &nodes, elements_t const &elements, Args...)
{
    return mesh<tmp::vector<typename tag2type<Args>::type...> >(nodes, elements);
}
 
 
template <class Mesh, class Elem>
class homogeneous_submesh
    : public mesh_base<homogeneous_submesh<Mesh, Elem>>
{
public:
    typedef Mesh mesh_t;
    typedef Elem elem_t;
 
    homogeneous_submesh(mesh_t const &parent) : m_parent(parent)
    {
    }
 
    typename mesh_t::template elem_iterator_t<elem_t>::type begin() const
    {
        return m_parent.template begin<elem_t>();
    }
 
    typename mesh_t::template elem_iterator_t<elem_t>::type end() const
    {
        return m_parent.template end<elem_t>();
    }
 
    Elem const &get_elem(int i) const
    {
        return m_parent.template get_elem<elem_t>(i);
    }
 
private:
    mesh_t const &m_parent;
};
 
template <class Mesh, class Tag>
homogeneous_submesh<Mesh, typename tag2type<Tag>::type>
create_homogeneous_submesh(Mesh const &mesh, Tag)
{
    return homogeneous_submesh<Mesh, typename tag2type<Tag>::type >(mesh);
}
 
}
 
#endif /* NIHU_MESH_HPP_INCLUDED */