material.hpp

Go to the documentation of this file.

/*
 * This file is part of PLaSK (https://plask.app) by Photonics Group at TUL
 * Copyright (c) 2022 Lodz University of Technology
 *
 * This program 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, version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 */
#ifndef PLASK__MATERIAL_H
#define PLASK__MATERIAL_H
 
#include <string>
#include <map>
#include <vector>
#include <functional>
#include <tuple>
#include <type_traits>
 
#include "../math.hpp"
#include "../memory.hpp"
#include "../exceptions.hpp"
#include "../phys/constants.hpp"
#include "../phys/functions.hpp"
#include "../vector/tensor2.hpp"
#include "../vector/tensor3.hpp"
#include "../parallel.hpp"
#include "../optional.hpp"
 
#define RETURN_MATERIAL_NAN(param) \
    static bool warn = true; \
    if (warn) { writelog(LOG_WARNING, "Material {}: non-applicable parameter " BOOST_PP_STRINGIZE(param) " returned as NAN", name()); warn = false; } \
    return NAN;
 
namespace plask {
 
extern PLASK_API OmpNestedLock material_omp_lock;
 
int elementGroup(const std::string& objectName);
 
struct MaterialsDB;
 
struct PLASK_API Material {
 
    enum Kind: unsigned {
        GENERIC        = (1<<0), 
        EMPTY          = (1<<1), 
        SEMICONDUCTOR  = (1<<2), 
        OXIDE          = (1<<3), 
        DIELECTRIC     = (1<<4), 
        METAL          = (1<<5), 
        LIQUID_CRYSTAL = (1<<6), 
        MIXED          = (1<<7)  
    };
 
    enum ConductivityType {
        CONDUCTIVITY_N,           
        CONDUCTIVITY_I,           
        CONDUCTIVITY_P,           
        CONDUCTIVITY_OTHER,       
        CONDUCTIVITY_UNDETERMINED 
    };
 
    typedef std::map<std::string, double> Composition;
 
 
  private:
 
    template <typename MaterialType>
    struct is_with_composition {
        static const bool value =
            std::is_constructible<MaterialType, Composition>::value ||
            std::is_constructible<MaterialType, Composition, double>::value;
    };
 
    template <typename MaterialType>
    struct is_with_dopant {
        static const bool value =
            std::is_constructible<MaterialType, double>::value ||
            std::is_constructible<MaterialType, Composition, double>::value;
    };
 
    friend struct MaterialsDB;
 
  public:
 
    static bool isNameWithDopant(const std::string& material_name) { return material_name.find(':') != std::string::npos; }
 
 
 
    static bool isSimpleMaterialName(const std::string &material_name) {
        auto brace = material_name.find('(');
        return brace == std::string::npos || brace == 0;
    }
 
    struct PLASK_API Parameters {
 
        std::string name;
 
        std::string label;
 
        Composition composition;
 
        std::string dopant;
 
        double doping;
 
        Parameters(): doping(0.) {}
 
        explicit Parameters(const std::string& full_name, bool allow_dopant_without_amount = false)
            { parse(full_name, allow_dopant_without_amount); }
 
        bool operator==(const Parameters& other) const {
            return name == other.name && label == other.label && composition == other.composition &&
                   dopant == other.dopant && doping == other.doping;
        }
 
        bool isAlloy() const { return !composition.empty(); }
 
        bool hasDopantName() const { return !dopant.empty(); }
 
        bool hasDoping() const { return !isnan(doping) && hasDopantName(); }
 
        void parse(const std::string& full_material_str, bool allow_dopant_without_amount = false);
 
        Composition completeComposition() const;
 
        void setDoping(const std::string& dopant, double doping);
 
        void clearDoping() {
            setDoping("", 0.);
        }
 
        std::string str() const;
    };
 
    struct PLASK_API StringBuilder {
 
        std::stringstream str;
 
        operator std::string() const { return str.str(); }
 
        StringBuilder& operator()(const std::string& objectName) { str << objectName; return *this; }
 
        StringBuilder(const std::string& objectName) {
            this->operator ()(objectName);
        }
 
        StringBuilder& operator()(const std::string& objectName, double ammount);
 
        StringBuilder(const std::string& objectName, double ammount) {
            this->operator ()(objectName, ammount);
        }
 
        std::string dopant(const std::string& dopant, double dopantConcentration);
    };
 
    static std::pair<std::string, double> firstCompositionObject(const char*& begin, const char* end, const char* fullname);
 
    static Composition completeComposition(const Composition& composition);
 
    static Composition minimalComposition(const Composition& composition);
 
    static Composition parseComposition(const char* begin, const char* end, const char* fullname = nullptr);
 
    static Composition parseComposition(const std::string& composition_str, const std::string& fullname = "");
 
    static void parseDopant(const char* begin, const char* end, std::string& dopant_elem_name, double& doping, bool allow_dopant_without_amount, const char* fullname);
 
    static void parseDopant(const std::string& dopant, std::string& dopant_elem_name, double& doping, bool allow_dopant_without_amount, const std::string& fullname);
 
    static std::vector<std::string> parseObjectsNames(const char* begin, const char* end);
 
    static std::vector<std::string> parseObjectsNames(const std::string& allNames);
 
    virtual OmpLockGuard lock() const {
        return OmpLockGuard();
    }
 
    virtual ~Material() {}
 
    virtual std::string name() const = 0;
 
    std::string dopant() const;
 
    std::string nameWithoutDopant() const;
 
    virtual std::string str() const;
 
    bool isAlloy() const;
 
    virtual Composition composition() const;
 
    virtual double doping() const;
 
    virtual Kind kind() const = 0;
 
    virtual double lattC(double T, char x) const;
 
    virtual double Eg(double T, double e=0., char point='*') const;
 
    virtual double CB(double T, double e=0., char point='*') const;
 
    virtual double VB(double T, double e=0., char point='*', char hole='H') const;
 
    virtual double Dso(double T, double e=0.) const;
 
    virtual double Mso(double T, double e=0.) const;
 
    virtual Tensor2<double> Me(double T, double e=0., char point='*') const;
 
    virtual Tensor2<double> Mhh(double T, double e=0.) const;
 
    virtual Tensor2<double> Mlh(double T, double e=0.) const;
 
    virtual Tensor2<double> Mh(double T, double e=0.) const;
 
    virtual double y1() const;
 
    virtual double y2() const;
 
    virtual double y3() const;
 
    virtual double ac(double T) const;
 
    virtual double av(double T) const;
 
    virtual double b(double T) const;
 
    virtual double d(double T) const;
 
    virtual double c11(double T) const;
 
    virtual double c12(double T) const;
 
    virtual double c44(double T) const;
 
    virtual double eps(double T) const;
 
    virtual Tensor3<dcomplex> Eps(double lam, double T, double n = 0) const;
 
    virtual double chi(double T, double e=0., char point='*') const;
 
    virtual double Ni(double T) const;
 
    virtual double Nf(double T) const;
 
    virtual double EactD(double T) const;
 
    virtual double EactA(double T) const;
 
    virtual Tensor2<double> mob(double T) const;
 
    virtual Tensor2<double> cond(double T) const;
 
    virtual ConductivityType condtype() const;
 
    virtual double A(double T) const;
 
    virtual double B(double T) const;
 
    virtual double C(double T) const;
 
    virtual double D(double T) const;
 
    virtual Tensor2<double> thermk(double T, double h=INFINITY) const;
 
    virtual double dens(double T) const;
 
    virtual double cp(double T) const;
 
    virtual double nr(double lam, double T, double n = 0) const;
 
    virtual double absp(double lam, double T) const;
 
    virtual dcomplex Nr(double lam, double T, double n = 0) const;
 
    virtual Tensor2<double> mobe(double T) const;
 
    virtual Tensor2<double> mobh(double T) const;
 
    virtual double taue(double T) const;
 
    virtual double tauh(double T) const;
 
    virtual double Ce(double T) const;
 
    virtual double Ch(double T) const;
 
    virtual double e13(double T) const;
 
    virtual double e15(double T) const;
 
    virtual double e33(double T) const;
 
    virtual double c13(double T) const;
 
    virtual double c33(double T) const;
 
    virtual double Psp(double T) const;
 
    virtual double Na() const;
 
    virtual double Nd() const;
 
 
 
    bool operator==(const Material& other) const;
 
    bool operator==(shared_ptr<const Material> other) const {
        return other ? this->operator==(*other) : false;
    }
 
    bool operator!=(const Material& other) const { return !this->operator==(other); }
 
    bool operator!=(shared_ptr<const Material> other) const { return !this->operator==(other); }
 
protected:
 
    virtual bool isEqual(const Material& other) const;
 
    [[noreturn]] void throwNotImplemented(const std::string& method_name) const;
};
 
 
struct PLASK_API DummyMaterial: public Material {
 
  protected:
    std::string _name;
 
  public:
 
    DummyMaterial(const std::string name): _name(name) {}
 
    std::string name() const override { return _name; }
 
    Kind kind() const override { return GENERIC; }
};
 
struct PLASK_API Semiconductor: public Material {
    static constexpr const char* NAME = "semiconductor";
    std::string name() const override;
    Kind kind() const override;
};
 
struct PLASK_API Metal: public Material {
    static constexpr const char* NAME = "metal";
    std::string name() const override;
    Kind kind() const override;
    double eps(double T) const override;
 
};
 
struct PLASK_API Oxide: public Material {
    static constexpr const char* NAME = "oxide";
    std::string name() const override;
    Kind kind() const override;
};
 
struct PLASK_API Dielectric: public Material {
    static constexpr const char* NAME = "dielectric";
    std::string name() const override;
    Kind kind() const override;
};
 
struct PLASK_API LiquidCrystal: public Material {
    static constexpr const char* NAME = "liquid_crystal";
    std::string name() const override;
    Kind kind() const override;
};
 
struct PLASK_API GenericMaterial : public Material {
    std::string name() const override { return ""; }
    Material::Kind kind() const override { return Material::GENERIC; }
    bool isEqual(const Material&) const override { return true; } // all generic materials are always equal
};
 
struct PLASK_API MaterialWithBase: public Material {
    shared_ptr<Material> base;
 
    MaterialWithBase() = default;
    MaterialWithBase(const shared_ptr<Material>& base): base(base) {}
    MaterialWithBase(Material* base): base(base) {}
};
 
struct PLASK_API MaterialCache {
    plask::optional<double> lattC;
    plask::optional<double> Eg;
    plask::optional<double> CB;
    plask::optional<double> VB;
    plask::optional<double> Dso;
    plask::optional<double> Mso;
    plask::optional<Tensor2<double>> Me;
    plask::optional<Tensor2<double>> Mhh;
    plask::optional<Tensor2<double>> Mlh;
    plask::optional<Tensor2<double>> Mh;
    plask::optional<double> ac;
    plask::optional<double> av;
    plask::optional<double> b;
    plask::optional<double> d;
    plask::optional<double> c11;
    plask::optional<double> c12;
    plask::optional<double> c44;
    plask::optional<double> eps;
    plask::optional<Tensor3<dcomplex>> Eps;
    plask::optional<double> chi;
    plask::optional<double> Na;
    plask::optional<double> Nd;
    plask::optional<double> Ni;
    plask::optional<double> Nf;
    plask::optional<double> EactD;
    plask::optional<double> EactA;
    plask::optional<Tensor2<double>> mob;
    plask::optional<Tensor2<double>> cond;
    plask::optional<double> A;
    plask::optional<double> B;
    plask::optional<double> C;
    plask::optional<double> D;
    plask::optional<Tensor2<double>> thermk;
    plask::optional<double> dens;
    plask::optional<double> cp;
    plask::optional<double> nr;
    plask::optional<double> absp;
    plask::optional<dcomplex> Nr;
    plask::optional<Tensor2<double>> mobe;
    plask::optional<Tensor2<double>> mobh;
    plask::optional<double> taue;
    plask::optional<double> tauh;
    plask::optional<double> Ce;
    plask::optional<double> Ch;
    plask::optional<double> e13;
    plask::optional<double> e15;
    plask::optional<double> e33;
    plask::optional<double> c13;
    plask::optional<double> c33;
    plask::optional<double> Psp;
    plask::optional<double> y1;
    plask::optional<double> y2;
    plask::optional<double> y3;
 
    bool operator==(const MaterialCache& other) const {
        return
            lattC == other.lattC &&
            Eg == other.Eg &&
            CB == other.CB &&
            VB == other.VB &&
            Dso == other.Dso &&
            Mso == other.Mso &&
            Me == other.Me &&
            Mhh == other.Mhh &&
            Mlh == other.Mlh &&
            Mh == other.Mh &&
            ac == other.ac &&
            av == other.av &&
            b == other.b &&
            d == other.d &&
            c11 == other.c11 &&
            c12 == other.c12 &&
            c44 == other.c44 &&
            eps == other.eps &&
            chi == other.chi &&
            Na == other.Na &&
            Nd == other.Nd &&
            Ni == other.Ni &&
            Nf == other.Nf &&
            EactD == other.EactD &&
            EactA == other.EactA &&
            mob == other.mob &&
            cond == other.cond &&
            A == other.A &&
            B == other.B &&
            C == other.C &&
            D == other.D &&
            thermk == other.thermk &&
            dens == other.dens &&
            cp == other.cp &&
            nr == other.nr &&
            absp == other.absp &&
            Nr == other.Nr &&
            Eps == other.Eps &&
            mobe == other.mobe &&
            mobh == other.mobh &&
            taue == other.taue &&
            tauh == other.tauh &&
            Ce == other.Ce &&
            Ch == other.Ch &&
            e13 == other.e13 &&
            e15 == other.e15 &&
            e33 == other.e33 &&
            c13 == other.c13 &&
            c33 == other.c33 &&
            Psp == other.Psp &&
            y1 == other.y1 &&
            y2 == other.y2 &&
            y3 == other.y3;
    }
};
 
} // namespace plask
 
#endif  //PLASK__MATERIAL_H