single_layer.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_OPS_SINGLE_LAYER_H
#define BEM_RWG_OPS_SINGLE_LAYER_H
 
#include "types.hpp"
#include "geometry/primitives/triangle.hpp"
 
#include "rwg/operators/base.hpp"
 
#include "rwg/integrators/obs/base.hpp"
#include "rwg/integrators/obs/strategic.hpp"
 
 
namespace bem::rwg
{
 
template <typename ObsIntegratorType = ObsStrategic<>>
class VectorSingleLayerOp: public OperatorBase<3, 3>
{
 
    static_assert(
        std::is_base_of<ObsIntegratorBase, ObsIntegratorType>::value,
        "VectorSingleLayerOp: `ObsIntegratorType` must derive from `ObsIntegratorBase`"
        );
 
public:
 
    VectorSingleLayerOp(const ObsIntegratorType obs_integrator = ObsStrategic<>()):
        obs_integrator_(obs_integrator) {};
 
 
    EigMatMN<Complex, 3, 3> compute(
        const Complex k,
        const Triangle<3>& obs_tri,
        const Triangle<3>& src_tri
        ) override;
 
 
    EigMatMN<Complex, 3, 3> assemble(
        const Complex k,
        const Triangle<3>& obs_tri,
        const Triangle<3>& src_tri,
        const ObsResult& obs_result
        );
 
 
protected:
 
    ObsIntegratorType obs_integrator_;
 
};
 
 
template <typename ObsIntegratorType = ObsStrategic<>>
class RotVectorSingleLayerOp: public OperatorBase<3, 3>
{
 
    static_assert(
        std::is_base_of<ObsIntegratorBase, ObsIntegratorType>::value,
        "RotVectorSingleLayerOp: `ObsIntegratorType` must derive from `ObsIntegratorBase`"
        );
 
public:
 
    RotVectorSingleLayerOp(const ObsIntegratorType obs_integrator = ObsStrategic<>()):
        obs_integrator_(obs_integrator) {};
 
 
    EigMatMN<Complex, 3, 3> compute(
        const Complex k,
        const Triangle<3>& obs_tri,
        const Triangle<3>& src_tri
        ) override;
 
 
    EigMatMN<Complex, 3, 3> assemble(
        const Complex k,
        const Triangle<3>& obs_tri,
        const Triangle<3>& src_tri,
        const ObsResult& obs_result
        );
 
 
protected:
 
    ObsIntegratorType obs_integrator_;
 
};
 
 
template <typename ObsIntegratorType = ObsStrategic<>>
class ScalarSingleLayerOp: public OperatorBase<1, 1>
{
 
    static_assert(
        std::is_base_of<ObsIntegratorBase, ObsIntegratorType>::value,
        "ScalarSingleLayerOp: `ObsIntegratorType` must derive from `ObsIntegratorBase`"
        );
 
public:
 
    ScalarSingleLayerOp(const ObsIntegratorType obs_integrator = ObsStrategic<>()):
        obs_integrator_(obs_integrator) {};
 
 
    EigMatMN<Complex, 1, 1> compute(
        const Complex k,
        const Triangle<3>& obs_tri,
        const Triangle<3>& src_tri
        ) override;
 
 
    EigMatMN<Complex, 1, 1> assemble(
        const Complex k,
        const Triangle<3>& obs_tri,
        const Triangle<3>& src_tri,
        const ObsResult& obs_result
        );
 
 
protected:
 
    ObsIntegratorType obs_integrator_;
 
};
 
 
template <typename ObsIntegratorType = ObsStrategic<>>
class RotGradScalarSingleLayerOp: public OperatorBase<3, 1>
{
 
    static_assert(
        std::is_base_of<ObsIntegratorBase, ObsIntegratorType>::value,
        "RotGradScalarSingleLayerOp: `ObsIntegratorType` must derive from `ObsIntegratorBase`"
        );
 
public:
 
    RotGradScalarSingleLayerOp(const ObsIntegratorType obs_integrator = ObsStrategic<>()):
        obs_integrator_(obs_integrator) {};
 
 
    EigMatMN<Complex, 3, 1> compute(
        const Complex k,
        const Triangle<3>& obs_tri,
        const Triangle<3>& src_tri
        ) override;
 
 
    EigMatMN<Complex, 3, 1> assemble(
        const Complex k,
        const Triangle<3>& obs_tri,
        const Triangle<3>& src_tri,
        const ObsResult& obs_result
        );
 
 
protected:
 
    ObsIntegratorType obs_integrator_;
 
};
 
 
template <typename ObsIntegratorType = ObsStrategic<>>
class VectorHypersingularOp: public OperatorBase<3, 3>
{
 
    static_assert(
        std::is_base_of<ObsIntegratorBase, ObsIntegratorType>::value,
        "VectorHypersingularOp: `ObsIntegratorType` must derive from `ObsIntegratorBase`"
        );
 
public:
 
    VectorHypersingularOp(const ObsIntegratorType obs_integrator = ObsStrategic<>()):
        op_g_(obs_integrator), op_hessg_(obs_integrator) {};
 
 
    EigMatMN<Complex, 3, 3> compute(
        const Complex k,
        const Triangle<3>& obs_tri,
        const Triangle<3>& src_tri
        ) override;
 
 
protected:
 
    VectorSingleLayerOp<ObsIntegratorType> op_g_;
    ScalarSingleLayerOp<ObsIntegratorType> op_hessg_;
 
};
 
 
template <typename ObsIntegratorType = ObsStrategic<>>
class RotVectorHypersingularOp: public OperatorBase<3, 3>
{
 
    static_assert(
        std::is_base_of<ObsIntegratorBase, ObsIntegratorType>::value,
        "RotVectorHypersingularOp: `ObsIntegratorType` must derive from `ObsIntegratorBase`"
        );
 
public:
 
    RotVectorHypersingularOp(const ObsIntegratorType obs_integrator = ObsStrategic<>()):
        op_g_(obs_integrator), op_hessg_(obs_integrator) {};
 
 
    EigMatMN<Complex, 3, 3> compute(
        const Complex k,
        const Triangle<3>& obs_tri,
        const Triangle<3>& src_tri
        ) override;
 
 
protected:
 
    RotVectorSingleLayerOp<ObsIntegratorType> op_g_;
    RotGradScalarSingleLayerOp<ObsIntegratorType> op_hessg_;
 
};
 
}
 
#include "rwg/operators/single_layer.tpp"
 
#endif