element_match.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 ELEMENT_MATCH_HPP_INCLUDED
#define ELEMENT_MATCH_HPP_INCLUDED
 
#include "element.hpp"
#include "match_types.hpp"
#include "field.hpp"
#include "formalism.hpp"
#include <type_traits>
#include <iostream>
 
namespace NiHu
{
 
class element_match
{
public:
    element_match(
        int match_dimension,
        element_overlapping const &overlap = element_overlapping())
        : m_match_dimension(match_dimension)
        , m_overlap(overlap)
    {
    }
 
    int get_match_dimension() const { return m_match_dimension; }
 
    element_overlapping const &get_overlap() const { return m_overlap; }
    
    std::ostream &print_debug(std::ostream &os = std::cout) const
    {
        os << "Element_match info:" << std::endl
            << "Match_dimension: " << m_match_dimension << std::endl;
        if (m_match_dimension != 2)
            m_overlap.print_debug(os);
        
        return os;
    }
 
private:
    int m_match_dimension;
    element_overlapping const m_overlap;
};
 
 
template <class test_field_t, class trial_field_t>
element_match element_match_eval(
    field_base<test_field_t> const &test_field,
    field_base<trial_field_t> const &trial_field)
{
    // face match is only possible if the element types are the same
    // (not dealing with 3d volume elements)
    bool const face_match_possible = std::is_same<
        typename test_field_t::elem_t,
        typename trial_field_t::elem_t
    >::value;
 
    // actual face match: if the elem id's are the same (same element)
    if (face_match_possible) // compile time if
        if (test_field.get_elem().get_id() == trial_field.get_elem().get_id())
            return element_match(test_field_t::elem_t::domain_t::dimension);
 
    typedef typename shape_set_traits::position_dof_vector<typename test_field_t::nset_t>::type test_dof_vector;
 
    // lower dimensional checks are needed for
    // - galerkin formulations in general
    // - collocational formulations if the test field contains nodes on the boundary
    if (std::is_same<typename get_formalism<test_field_t, trial_field_t>::type, formalism::general>::value
        || tmp::is_member<test_dof_vector, dof1 >::value && (test_field_t::elem_t::domain_t::dimension > 1)
        || tmp::is_member<test_dof_vector, dof0 >::value)
    {
        element_overlapping overlap(test_field.get_elem().get_overlapping(trial_field.get_elem()));
 
        // edge match
        if (overlap.get_num() > 1)
            return element_match(1, overlap);
 
        // vertex match
        if (overlap.get_num() == 1)
            return element_match(0, overlap);
    }
 
    // no match
    return element_match(-1);
}
 
}
 
#endif // ELEMENT_MATCH_HPP_INCLUDED