kernel.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 KERNEL_HPP_INCLUDED
#define KERNEL_HPP_INCLUDED
 
#include "complexity_estimator.hpp"
#include "asymptotic_types.hpp"
#include "../util/crtp_base.hpp"
#include "../library/interval_estimator.hpp"
#include "../library/distance_kernel_intervals.hpp"
 
namespace NiHu
{
 
namespace kernel_traits_ns
{
    template <class Derived> struct space;
    template <class Derived> struct test_input;
    template <class Derived> struct trial_input;
    template <class Derived> struct result;
    template <class Derived> struct quadrature_family;
    template <class Derived> struct far_field_behaviour;
 
    template <class Derived> struct is_symmetric;
    template <class Derived> struct is_singular;
 
    template <class Derived> struct singularity_type;
    template <class Derived> struct singular_quadrature_order;
    template <class Derived> struct singular_core;
}
 
template <class Derived>
struct kernel_traits
{
    typedef typename kernel_traits_ns::space<Derived>::type space_t;
    typedef typename kernel_traits_ns::test_input<Derived>::type test_input_t;
    typedef typename kernel_traits_ns::trial_input<Derived>::type trial_input_t;
    typedef typename kernel_traits_ns::result<Derived>::type result_t;
    typedef typename kernel_traits_ns::far_field_behaviour<Derived>::type far_field_behaviour_t;
    typedef typename kernel_traits_ns::quadrature_family<Derived>::type quadrature_family_t;
 
    enum {
        is_symmetric = kernel_traits_ns::is_symmetric<Derived>::value,
        is_singular = kernel_traits_ns::is_singular<Derived>::value
    };
};
 
 
template <class Derived>
struct singular_kernel_traits
{
    typedef typename kernel_traits_ns::singularity_type<Derived>::type singularity_type_t;
    typedef typename kernel_traits_ns::singular_core<Derived>::type singular_core_t;
 
    enum {
        singular_quadrature_order = kernel_traits_ns::singular_quadrature_order<Derived>::value
    };
};
 
 
 
template <class Derived>
struct kernel_compl_estimator
{
    typedef interval_estimator<
        typename distance_kernel_interval<
            typename kernel_traits<Derived>::far_field_behaviour_t
        >::type
    > type;
};
 
 
template <class Derived>
class kernel_base
{
public:
    NIHU_CRTP_HELPERS
 
    typedef kernel_traits<Derived> traits_t;
 
    typedef typename traits_t::test_input_t test_input_t;
    typedef typename traits_t::trial_input_t trial_input_t;
    static_assert(std::is_same<typename test_input_t::space_t, typename trial_input_t::space_t>::value,
        "The test and trial kernel inputs must define the same coordinate space");
    typedef typename traits_t::result_t result_t;
 
    typedef typename test_input_t::space_t space_t;
    typedef typename space_t::location_t x_t;
    typedef typename space_t::scalar_t scalar_t;
 
    typedef typename traits_t::quadrature_family_t quadrature_family_t;
 
    static bool const is_symmetric = traits_t::is_symmetric;
 
    static bool const is_sungular = traits_t::is_singular;
 
    typedef typename traits_t::far_field_behaviour_t far_field_behaviour_t;
 
    typedef typename kernel_compl_estimator<Derived>::type estimator_t;
 
    class kernel_bind
    {
    public:
        kernel_bind(kernel_base<Derived> const &kernel, test_input_t const &x)
            : m_kernel(kernel.derived()), m_test_input(x)
        {
        }
 
        result_t operator()(trial_input_t const &y) const
        {
            return m_kernel(m_test_input, y);
        }
 
    private:
        Derived const &m_kernel;
        test_input_t const &m_test_input;
    };
 
    kernel_bind bind(test_input_t const &x) const
    {
        return kernel_bind(*this, x);
    }
 
    result_t operator()(test_input_t const &x, trial_input_t const &y) const
    {
        return derived()(x, y);
    }
};
 
} // end of namespace NiHu
 
#endif // KERNEL_HPP_INCLUDED