strategic.hpp

Go to the documentation of this file.

// OpenBEM - Copyright (C) 2026 Shashwat Sharma
 
// This file is part of OpenBEM.
 
// OpenBEM 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.
 
// You should have received a copy of the GNU General Public License along with OpenBEM.
// If not, see <https://www.gnu.org/licenses/>.
 
 
#ifndef BEM_RWG_OPINT_OBS_STRATEGIC_H
#define BEM_RWG_OPINT_OBS_STRATEGIC_H
 
#include <memory>
 
#include "types.hpp"
 
#include "geometry/primitives/triangle.hpp"
#include "quadrature/triangle/base.hpp"
#include "quadrature/triangle/gauss.hpp"
#include "quadrature/line/base.hpp"
#include "quadrature/line/gauss.hpp"
 
#include "kernels/hgf.hpp"
#include "rwg/integrators/obs/base.hpp"
#include "rwg/integrators/obs/quadrature.hpp"
#include "rwg/integrators/src/base.hpp"
#include "rwg/integrators/src/quadrature.hpp"
#include "rwg/integrators/src/singularity.hpp"
#include "rwg/integrators/src/line.hpp"
 
 
namespace bem::rwg
{
 
struct IntegrationSettings
{
 
    Float obs_quad_order_far = 4;
 
    Float obs_quad_order_near = 8;
 
    Float src_quad_order_far = 4;
 
    Float src_quad_order_near = 8;
 
    Float src_line_order = 10;
 
    Float threshold_wvl_singularity = 0.1;
 
    Float threshold_dist_singularity = -1;
 
    Float threshold_length_line_int = 1;
 
    Float threshold_skin_depths = 10;
 
};
 
 
template <
    typename ObsTriangleQuadratureType = GaussTriangleQuadrature<3>,
    typename SrcTriangleQuadratureType = GaussTriangleQuadrature<2>,
    typename LineQuadratureType = GaussLineQuadrature<1>
    >
class ObsStrategic: public ObsIntegratorBase
{
 
    using base = ObsIntegratorBase;
    static_assert(
        std::is_base_of<TriangleQuadratureBase<3>, ObsTriangleQuadratureType>::value,
        "ObsStrategic: `ObsTriangleQuadratureType` must derive from `TriangleQuadratureBase<3>`"
        );
    static_assert(
        std::is_base_of<TriangleQuadratureBase<2>, SrcTriangleQuadratureType>::value,
        "ObsStrategic: `SrcTriangleQuadratureType` must derive from `TriangleQuadratureBase<2>`"
        );
    static_assert(
        std::is_base_of<LineQuadratureBase<1>, LineQuadratureType>::value,
        "ObsStrategic: `LineQuadratureType` must derive from `LineQuadratureBase<1>`"
        );
 
public:
 
    ObsStrategic(
        const IntegrationSettings settings = IntegrationSettings(),
        const ObsTriangleQuadratureType obs_tri_quad = GaussTriangleQuadrature<3>(),
        const SrcTriangleQuadratureType src_tri_quad = GaussTriangleQuadrature<2>(),
        const LineQuadratureType src_line_quad = GaussLineQuadrature<1>()
        ):
            settings_(settings),
            hgf_(obs_tri_quad, SrcQuadrature(src_tri_quad, HGF())),
            shgf_(obs_tri_quad, SrcSingularity(src_tri_quad, SingularitySubtractedHGF())),
            sthgf_(obs_tri_quad, SrcSingularity(src_tri_quad, SingularitySubtractedTaylorHGF())),
            line_(obs_tri_quad, SrcLineIntegrator(src_line_quad))
    {
        line_.quadrature_object().set_order(settings_.obs_quad_order_far);
        sthgf_.quadrature_object().set_order(settings_.obs_quad_order_near);
        shgf_.quadrature_object().set_order(settings_.obs_quad_order_near);
        hgf_.quadrature_object().set_order(settings_.obs_quad_order_far);
 
        line_.src_integrator().quadrature_object().set_order(settings_.src_line_order);
        sthgf_.src_integrator().quadrature_object().set_order(settings_.src_quad_order_near);
        shgf_.src_integrator().quadrature_object().set_order(settings_.src_quad_order_near);
        hgf_.src_integrator().quadrature_object().set_order(settings_.src_quad_order_far);
 
        return;
    };
 
 
    ObsResult integrate(
        const Complex k,
        const Triangle<3>& obs_tri,
        const Triangle<2>& src_tri
        ) override;
 
 
private:
 
    IntegrationSettings settings_;
 
    ObsQuadrature<ObsTriangleQuadratureType, SrcQuadrature<SrcTriangleQuadratureType, HGF>> hgf_;
    ObsQuadrature<ObsTriangleQuadratureType, SrcSingularity<SrcTriangleQuadratureType, SingularitySubtractedHGF>> shgf_;
    ObsQuadrature<ObsTriangleQuadratureType, SrcSingularity<SrcTriangleQuadratureType, SingularitySubtractedTaylorHGF>> sthgf_;
    ObsQuadrature<ObsTriangleQuadratureType, SrcLineIntegrator<LineQuadratureType>> line_;
 
};
 
}
 
#include "rwg/integrators/obs/strategic.tpp"
 
#endif