aefie.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_AEFIE_LUMPED_ELEM_H
#define BEM_RWG_AEFIE_LUMPED_ELEM_H
 
#include <vector>
 
#include "types.hpp"
#include "constants.hpp"
 
#include "geometry/mesh/base.hpp"
#include "matrix/base.hpp"
#include "matrix/eigen_dense.hpp"
 
#include "rwg/operators/single_layer.hpp"
#include "rwg/operators/incidence.hpp"
#include "rwg/assemblers/operator_matrix.hpp"
#include "rwg/lumped_elements/base.hpp"
 
 
namespace bem::rwg
{
 
template <typename MatrixType = EigenDenseMatrix<Complex>>
class AefieLumpedElement: public LumpedElementBase<MatrixType>
{
 
    using base = LumpedElementBase<MatrixType>;
    using base::base;
 
public:
 
    MatrixType coupling_matrix(const Float f) const override
    {
        MatrixType mat;
        mat.set_mat_mul(base::terminal_mapping_matrix(), base::current_mapping_matrix());
        return mat;
    };
 
 
    MatrixType voltage_matrix(const Float f) const override
    {
        TriangleMesh<3> port_mesh = base::port_mesh_view().mesh();
        MatrixType voltage_map = base::voltage_mapping_matrix();
        MatrixType Lp = phi_matrix(f, port_mesh, base::structure_.mesh());
 
        MatrixType mat;
        mat.set_mat_mul(voltage_map, Lp, -one);
 
        return mat;
    };
 
 
    MatrixType current_matrix(const Float f) const override
    {
        MatrixType mat (base::num_ports(), base::num_ports());
        for (Index ii = 0; ii < base::num_ports(); ++ii)
            mat.set_value(ii, ii, base::impedances()[ii]);
        mat.assemble();
        return mat;
    };
 
 
protected:
 
    MatrixType phi_matrix(
        const Float f,
        const TriangleMesh<3>& obs_mesh,
        const TriangleMesh<3>& src_mesh
        ) const
    {
        Complex k = base::structure_.background_material().k(f);
        Complex eps_eff = base::structure_.background_material().eps_eff(f);
 
        ScalarSingleLayerOp op_Lp;
        FaceOperatorAssembler assm_face (obs_mesh, src_mesh);
        MatrixType Lp;
        assm_face.assemble(Lp, op_Lp, k);
        Lp.scale(one / eps_eff);
 
        return Lp;
    };
 
};
 
}
 
#endif