convected_helmholtz_3d_nearly_singular_integrals.hpp

#ifndef NIHU_CONVECTED_HELMHOLTZ_3D_NEARLY_SINGULAR_INTEGRALS_HPP_INCLUDED
#define NIHU_CONVECTED_HELMHOLTZ_3D_NEARLY_SINGULAR_INTEGRALS_HPP_INCLUDED
 
#include "core/nearly_singular_integral.hpp"
 
#include "convected_helmholtz_3d_kernel.hpp"
#include "core/formalism.hpp"
#include "nearly_singular_collocational_telles.hpp"
 
#define NIHU_MEX_DEBUGGING 0
 
 
#if NIHU_MEX_DEBUGGING
#include "mex.h"
#endif
 
namespace NiHu
{
 
// Convected 3D DLP
template <class TestField, class TrialField, class WaveNumber>
class nearly_singular_integral<
    convected_helmholtz_3d_DLP_kernel<WaveNumber>, TestField, TrialField,
    typename std::enable_if<
        is_collocational<TestField, TrialField>::value 
    >::type
>
{
    typedef convected_helmholtz_3d_DLP_kernel<WaveNumber> kernel_t;
    typedef typename kernel_t::test_input_t test_input_t;
    typedef TestField test_field_t;
    typedef typename test_field_t::nset_t test_nset_t;
    static unsigned const num_test_nodes = test_nset_t::num_nodes;
    
public:
    static bool needed(
        kernel_base<kernel_t> const &kernel,
        field_base<TestField> const &test_field,
        field_base<TrialField> const &trial_field
        )
    {
        double const limit = 1.5;
        
        // distance between element centres
        double d = (test_field.get_elem().get_center() - trial_field.get_elem().get_center()).norm();
        double R = trial_field.get_elem().get_linear_size_estimate();
        
        return d/R < limit;
    }
 
    template <class result_t>
    static result_t &eval(
        result_t &result,
        kernel_base<kernel_t> const &kernel,
        field_base<TestField> const &test_field,
        field_base<TrialField> const &trial_field
        )
    {
        typedef nearly_singular_collocational_telles<TrialField, kernel_t, 30> nsc_t;
        nsc_t nsc(trial_field, kernel);
        
        #if NIHU_MEX_DEBUGGING
            static bool printed = false;
            if (!printed) {
                mexPrintf("Nearly singular Telles for convected DLP\n");
                printed = true;
            }
        #endif
 
        for (unsigned i = 0; i < num_test_nodes; ++i)
        {
            test_input_t tsti(test_field.get_elem(), test_nset_t::corner_at(i));
            nsc.integrate(result.row(i), tsti);
        }
        
        return result;
    }
};
 
 
// Convected 3D DLPt
template <class TestField, class TrialField, class WaveNumber>
class nearly_singular_integral<
    convected_helmholtz_3d_DLPt_kernel<WaveNumber>, TestField, TrialField,
    typename std::enable_if<
        is_collocational<TestField, TrialField>::value 
    >::type
>
{
    typedef convected_helmholtz_3d_DLPt_kernel<WaveNumber> kernel_t;
    typedef typename kernel_t::test_input_t test_input_t;
    typedef TestField test_field_t;
    typedef typename test_field_t::nset_t test_nset_t;
    static unsigned const num_test_nodes = test_nset_t::num_nodes;
    
public:
    static bool needed(
        kernel_base<kernel_t> const &kernel,
        field_base<TestField> const &test_field,
        field_base<TrialField> const &trial_field
        )
    {
        double const limit = 1.5;
        
        // distance between element centres
        double d = (test_field.get_elem().get_center() - trial_field.get_elem().get_center()).norm();
        double R = trial_field.get_elem().get_linear_size_estimate();
        
        return d/R < limit;
    }
 
    template <class result_t>
    static result_t &eval(
        result_t &result,
        kernel_base<kernel_t> const &kernel,
        field_base<TestField> const &test_field,
        field_base<TrialField> const &trial_field
        )
    {
        typedef nearly_singular_collocational_telles<TrialField, kernel_t, 30> nsc_t;
        nsc_t nsc(trial_field, kernel);
        
        #if NIHU_MEX_DEBUGGING
            static bool printed = false;
            if (!printed) {
                mexPrintf("Nearly singular Telles for convected DLPt\n");
                printed = true;
            }
        #endif
 
 
        for (unsigned i = 0; i < num_test_nodes; ++i)
        {
            test_input_t tsti(test_field.get_elem(), test_nset_t::corner_at(i));
            nsc.integrate(result.row(i), tsti);
        }
        
        return result;
    }
};
 
 
// HSP
template <class TestField, class TrialField, class WaveNumber>
class nearly_singular_integral<
    convected_helmholtz_3d_HSP_kernel<WaveNumber>, TestField, TrialField,
    typename std::enable_if<
        is_collocational<TestField, TrialField>::value 
    >::type
>
{
    typedef convected_helmholtz_3d_HSP_kernel<WaveNumber> kernel_t;
    typedef typename kernel_t::test_input_t test_input_t;
    typedef TestField test_field_t;
    typedef typename test_field_t::nset_t test_nset_t;
    static unsigned const num_test_nodes = test_nset_t::num_nodes;
    
public:
    static bool needed(
        kernel_base<kernel_t> const &kernel,
        field_base<TestField> const &test_field,
        field_base<TrialField> const &trial_field
        )
    {
        double const limit = 1.5;
        
        // distance between element centres
        double d = (test_field.get_elem().get_center() - trial_field.get_elem().get_center()).norm();
        double R = trial_field.get_elem().get_linear_size_estimate();
        
        return d/R < limit;
    }
 
    template <class result_t>
    static result_t &eval(
        result_t &result,
        kernel_base<kernel_t> const &kernel,
        field_base<TestField> const &test_field,
        field_base<TrialField> const &trial_field
        )
    {
        typedef nearly_singular_collocational_telles<TrialField, kernel_t, 30> nsc_t;
        nsc_t nsc(trial_field, kernel);
        
        #if NIHU_MEX_DEBUGGING
            static bool printed = false;
            if (!printed) {
                mexPrintf("Nearly singular Telles for convected HSP\n");
                printed = true;
            }
        #endif
 
        for (unsigned i = 0; i < num_test_nodes; ++i)
        {
            test_input_t tsti(test_field.get_elem(), test_nset_t::corner_at(i));
            nsc.integrate(result.row(i), tsti);
        }
        
        return result;
    }
};
 
} // namespace NiHu
 
#endif /* NIHU_CONVECTED_HELMHOLTZ_3D_NEARLY_SINGULAR_INTEGRALS_HPP_INCLUDED */