weighted_residual.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 WEIGHTED_RESIDUAL_HPP_INCLUDED
#define WEIGHTED_RESIDUAL_HPP_INCLUDED
 
#include <type_traits>
 
#include "../tmp/bool.hpp"
#include "../util/crtp_base.hpp"
#include "result_matrix.hpp"
#include "function_space.hpp"
#include "integral_transform.hpp"
 
 
namespace NiHu
{
 
template <class Derived>
class wr_base
{
public:
    NIHU_CRTP_HELPERS
 
    template <class result_t>
    result_t &eval(result_t &result) const
    {
        return derived().eval(result);
    }
};
 
 
template <class TestSpace, class Projection>
class weighted_residual :
    public wr_base<weighted_residual<TestSpace, Projection> >
{
public:
    weighted_residual(
        TestSpace &&test,
        Projection &&proj) :
        m_test(std::forward<TestSpace>(test)),
        m_proj(std::forward<Projection>(proj))
    {
    }
 
    template <class result_t>
    result_t &eval(result_t &result) const
    {
        m_proj.test_on_into(m_test, result);
        return result;
    }
 
private:
    TestSpace m_test;
    Projection m_proj;
};
 
 
template <class Wr>
struct is_weighted_residual : std::is_base_of<
    wr_base<typename std::decay<Wr>::type>,
    typename std::decay<Wr>::type
>{};
 
 
template <class Left, class Right>
class wr_sum :
    public wr_base<wr_sum<Left, Right> >
{
public:
    wr_sum(Left &&left, Right &&right) :
        m_lhs(std::forward<Left>(left)), m_rhs(std::forward<Right>(right))
    {
    }
 
    template <class result_t>
    result_t &eval(result_t &result) const
    {
        m_lhs.eval(result);
        m_rhs.eval(result);
        return result;
    }
 
private:
    Left m_lhs;
    Right m_rhs;
};
 
 
template <class LeftWr, class RightWr>
wr_sum<
    typename std::enable_if<is_weighted_residual<LeftWr>::value, LeftWr>::type,
    typename std::enable_if<is_weighted_residual<RightWr>::value, RightWr>::type
>
    operator+(LeftWr &&lhs, RightWr &&rhs)
{
    return wr_sum<LeftWr, RightWr>(
        std::forward<LeftWr>(lhs),
        std::forward<RightWr>(rhs));
}
 
 
 
template <class Test, class Proj>
weighted_residual<
    typename std::enable_if<is_function_space<Test>::value, Test>::type,
    typename std::enable_if<is_integral_transform<Proj>::value, Proj>::type
>
    operator *(Test &&test, Proj &&proj)
{
    return weighted_residual<Test, Proj>(
        std::forward<Test>(test),
        std::forward<Proj>(proj));
}
 
 
 
template <class WR, class Res>
typename std::enable_if<
    is_weighted_residual<WR>::value && is_result_matrix<Res>::value,
    Res &
>::type
operator << (Res &res, WR &&wr)
{
    wr.eval(res);
    return res;
}
 
} // end of namespace NiHu
 
#endif // ifndef WEIGHTED_RESIDUAL_HPP_INCLUDED