materials.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 MATERIALS_H
#define MATERIALS_H
 
#include <stdexcept>
 
#include "types.hpp"
#include "constants.hpp"
 
 
namespace bem
{
 
const Float CONDUCTOR_LOSS_TAN_THRESHOLD = 10;
 
class Material
{
public:
 
    Material(
        const Complex epsr = one,
        const Complex mur = one,
        const Float sigma = 0
        ): epsr_(epsr), mur_(mur), sigma_(sigma) {};
 
 
    virtual Complex eps() const { return epsr_ * eps0; };
 
 
    virtual Complex epsr() const { return epsr_; };
 
 
    virtual Complex eps_eff(const Float f) const
    {
        if (std::abs(f) <= float_eps)
            return eps();
        else
            return eps() - J * sigma() / f / two_pi;
    };
 
 
    virtual Complex epsr_eff(const Float f) const { return eps_eff(f) / eps0; };
 
 
    virtual Complex mu() const { return mur_ * mu0; };
 
 
    virtual Complex mur() const { return mur_; };
 
 
    virtual Float sigma() const { return sigma_; };
 
 
    virtual Float loss_tan(const Float f) const
    { return -std::imag(eps_eff(f)) / std::real(eps_eff(f)); };
 
 
    virtual Complex eta(const Float f) const
    {
        if (std::abs(sigma()) <= float_eps)
            return std::sqrt(mu() / eps());
        else
            return std::sqrt((J * two_pi * f * mu()) / (J * two_pi * f * eps() + sigma()));
    }
    // { return std::sqrt(mu() / eps_eff(f)); };
 
 
    virtual Complex k(const Float f) const
    { return std::sqrt((-J * two_pi * f * mu()) * (J * two_pi * f * eps() + sigma())); };
    // { return two_pi * f * std::sqrt(eps_eff(f) * mu()); };
 
 
    virtual Float wvl(const Float f) const
    { return std::real(two_pi / k(f)); };
 
 
    virtual Complex c(const Float f) const
    { return one / std::sqrt(eps_eff(f) * mu()); };
 
 
    virtual Float skin_depth(const Float f) const
    { return -one / std::imag(k(f)); };
 
 
    virtual bool good_conductor(const Float f) const
    { return loss_tan(f) > CONDUCTOR_LOSS_TAN_THRESHOLD; };
 
 
protected:
 
    const Complex epsr_ = one;
    const Complex mur_ = one;
    const Float sigma_ = 0;
 
};
 
 
class PerfectDielectricMaterial: public Material
{
public:
 
    PerfectDielectricMaterial(
        const Float epsr = one,
        const Float mur = one
        ): Material(epsr, mur, 0) {};
 
 
    Float eta() const
    { return std::real(std::sqrt(mu() / eps())); };
 
 
    Float c() const
    { return one / std::real(std::sqrt(mu() * eps())); };
 
 
};
 
 
class ConstantLossTangentMaterial: public Material
{
public:
 
    ConstantLossTangentMaterial(
        const Float epsr = one,
        const Float mur = one,
        const Float loss_tan = 0
        ): Material(epsr, mur, 0), loss_tan_(loss_tan) {};
 
 
    Complex eps() const override
    { return epsr_ * eps0 * (one - J * loss_tan_); };
 
 
    Complex epsr() const override
    { return eps() / eps0; };
 
 
    Complex eps_eff(const Float f) const override
    { return eps(); };
 
 
    Float loss_tan() const
    { return loss_tan_; };
 
 
    Float loss_tan(const Float f) const override
    { return loss_tan(); };
 
 
protected:
 
    const Float loss_tan_ = 0;
 
};
 
}
 
#endif