db.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_DB_H
#define PLASK__MATERIAL_DB_H
 
#include <functional>
#include "material.hpp"
#include "const_material.hpp"
 
#include <boost/iterator/transform_iterator.hpp>
#include "../utils/system.hpp"
#include "../utils/warnings.hpp"
 
#include "info.hpp"
 
namespace plask {
 
struct PLASK_API MaterialsDB {
 
    static MaterialsDB& getDefault();
 
    struct TemporaryReplaceDefault;
    typedef TemporaryReplaceDefault TemporaryClearDefault;
 
    static void loadToDefault(const std::string& fileName_mainpart);
 
    static void loadAllToDefault(const std::string& dir = plaskMaterialsPath());
 
    void clear() {
        constructors.clear();
        info.clear();
    }
 
    void update(const MaterialsDB& src) {
        for (const auto& item: src.constructors) {
            constructors[item.first] = item.second;
        }
        info.update(src.info);
    }
 
    template <typename MaterialType>
    struct Register {
        Register(const std::string& name) { getDefault().add<MaterialType>(name); }
        Register() { getDefault().add<MaterialType>(); }
    };
 
    template <typename MaterialType>
    struct RegisterUnderName {
        RegisterUnderName(const std::string& name) { getDefault().add<MaterialType>(name); }
    };
 
    struct PLASK_API MaterialConstructor {
 
        std::string materialName;
 
        MaterialConstructor(const std::string& materialName): materialName(materialName) {}
 
        virtual shared_ptr<Material> operator()(const Material::Composition& composition, double doping) const = 0;
 
        virtual bool isAlloy() const = 0;
 
        virtual ~MaterialConstructor() {}
 
        void ensureCompositionIsEmpty(const Material::Composition& composition) const {
            if (!composition.empty()) throw Exception("redundant composition given for material '{0}'", materialName);
        }
 
        void ensureNoDoping(double doping) const {
            if (!isnan(doping) && doping != 0.) throw Exception("redundant doping given for material '{0}'", materialName);
        }
    };
 
    struct PLASK_API MixedCompositionFactory {
 
      protected:
 
        shared_ptr<const MaterialConstructor> constructor;
 
      public:
        MixedCompositionFactory(shared_ptr<const MaterialConstructor> constructor): constructor(constructor) {}
 
        virtual ~MixedCompositionFactory() {}
 
        virtual shared_ptr<Material> operator()(double m1_weight) const = 0;
 
        virtual shared_ptr<Material> singleMaterial() const = 0;
 
    };
 
    //TODO cache: double -> constructed material
    struct PLASK_API MixedCompositionOnlyFactory: public MixedCompositionFactory {    //TODO nonlinear mixing with functor double [0.0, 1.0] -> double [0.0, 1.0]
 
      protected:
 
        Material::Composition material1composition, material2composition;
 
        double shape;
 
        Material::Composition mixedComposition(double m1_weight) const;
 
      public:
        MixedCompositionOnlyFactory(shared_ptr<const MaterialConstructor> constructor, const Material::Composition& material1composition, const Material::Composition& material2composition, double shape=1.);
 
        shared_ptr<Material> operator()(double m1_weight) const override {
            return (*constructor)(mixedComposition(m1_weight), NAN);
        }
 
        shared_ptr<Material> singleMaterial() const override {
            return material1composition == material2composition ? (*constructor)(material1composition, NAN) : shared_ptr<Material>();
        }
    };
 
    struct PLASK_API MixedCompositionAndDopantFactory: public MixedCompositionOnlyFactory {
      protected:
        double m1DopAmount, m2DopAmount;
 
      public:
        MixedCompositionAndDopantFactory(shared_ptr<const MaterialConstructor> constructor, const Material::Composition& material1composition, const Material::Composition& material2composition,
                                         double m1DopAmount, double m2DopAmount, double shape=1.)
            : MixedCompositionOnlyFactory(constructor, material1composition, material2composition, shape), m1DopAmount(m1DopAmount), m2DopAmount(m2DopAmount) {}
 
        shared_ptr<Material> operator()(double m1_weight) const override {
            return (*constructor)(mixedComposition(m1_weight),
                                  m1DopAmount * pow(m1_weight, shape) + m2DopAmount * (1.0 - pow(m1_weight, shape)));
        }
 
        shared_ptr<Material> singleMaterial() const override {
            return (material1composition == material2composition) && (m1DopAmount == m2DopAmount) ?
                        (*constructor)(material1composition, m1DopAmount) : shared_ptr<Material>();
        }
    };
 
    struct PLASK_API MixedDopantFactory: public MixedCompositionFactory {
      protected:
        double m1DopAmount, m2DopAmount;
 
        double shape;
 
      public:
        MixedDopantFactory(shared_ptr<const MaterialConstructor> constructor, double m1DopAmount, double m2DopAmount, double shape=1.)
            : MixedCompositionFactory(constructor), m1DopAmount(m1DopAmount), m2DopAmount(m2DopAmount), shape(shape) {}
 
        shared_ptr<Material> operator()(double m1_weight) const override {
            return (*constructor)(Material::Composition(), m1DopAmount * pow(m1_weight, shape) + m2DopAmount * (1.0 - pow(m1_weight, shape)));
        }
 
        shared_ptr<Material> singleMaterial() const override {
            return m1DopAmount == m2DopAmount ? (*constructor)(Material::Composition(), m1DopAmount) : shared_ptr<Material>();
        }
    };
 
    struct PLASK_API DummyMixedCompositionFactory: public MixedCompositionFactory {
      protected:
        std::string full_name;
 
      public:
        DummyMixedCompositionFactory(const std::string& name1, const std::string& name2)
            : MixedCompositionFactory(shared_ptr<const MaterialConstructor>()), full_name(name1 + "..." + name2) {}
 
        shared_ptr<Material> operator()(double PLASK_UNUSED(m1_weight)) const override {
            return plask::make_shared<DummyMaterial>(full_name);
        }
 
        shared_ptr<Material> singleMaterial() const override {
            return plask::make_shared<DummyMaterial>(full_name);
        }
    };
 
  private:
 
    typedef std::map<std::string, shared_ptr<const MaterialConstructor> > constructors_map_t;
 
    constructors_map_t constructors;
 
    // Static const constructors_map_t::mapped_type& iter_val(const constructors_map_t::value_type &pair) { return pair.second; }
    struct iter_val: public std::function<const constructors_map_t::mapped_type&(const constructors_map_t::value_type&)> {
        const constructors_map_t::mapped_type& operator()(const constructors_map_t::value_type &pair) const { return pair.second; }
    };
 
public:
 
    MaterialInfo::DB info;
 
    typedef boost::transform_iterator<iter_val, constructors_map_t::const_iterator> iterator;
 
    typedef iterator const_iterator;
 
    const_iterator begin() const { return iterator(constructors.begin()); }
 
    const_iterator end() const { return iterator(constructors.end()); }
 
    size_t size() const {
        return constructors.size();
    }
 
    static void ensureCompositionIsNotEmpty(const Material::Composition& composition);
 
    template <typename MaterialType,
              bool requireComposition = Material::is_with_composition<MaterialType>::value,
              bool requireDopant = Material::is_with_dopant<MaterialType>::value >
    struct DelegateMaterialConstructor;
 
    template <typename MaterialType>
    struct DelegateMaterialConstructor<MaterialType, true, true>: public MaterialConstructor {
 
        DelegateMaterialConstructor(const std::string& material_name): MaterialConstructor(material_name) {}
 
        shared_ptr<Material> operator()(const Material::Composition& composition, double doping) const override {
            ensureCompositionIsNotEmpty(composition);
            return plask::make_shared<MaterialType>(Material::completeComposition(composition), doping);
        }
 
        bool isAlloy() const override { return true; }    // == ! requireComposition
    };
 
    template <typename MaterialType>
    struct DelegateMaterialConstructor<MaterialType, true, false>: public MaterialConstructor {
 
        DelegateMaterialConstructor(const std::string& material_name): MaterialConstructor(material_name) {}
 
        shared_ptr<Material> operator()(const Material::Composition& composition, double doping) const override {
            ensureCompositionIsNotEmpty(composition);
            ensureNoDoping(doping);
            return plask::make_shared<MaterialType>(Material::completeComposition(composition));
        }
 
        bool isAlloy() const override { return true; }
    };
 
    template <typename MaterialType>
    struct DelegateMaterialConstructor<MaterialType, false, true>: public MaterialConstructor {
 
        DelegateMaterialConstructor(const std::string& material_name): MaterialConstructor(material_name) {}
 
        shared_ptr<Material> operator()(const Material::Composition& composition, double doping) const override {
            ensureCompositionIsEmpty(composition);
            return plask::make_shared<MaterialType>(doping);
        }
 
        bool isAlloy() const override { return false; }
    };
 
    template <typename MaterialType>
    struct DelegateMaterialConstructor<MaterialType, false, false>: public MaterialConstructor {
 
        DelegateMaterialConstructor(const std::string& material_name): MaterialConstructor(material_name) {}
 
        shared_ptr<Material> operator()(const Material::Composition& composition, double doping) const override {
            ensureCompositionIsEmpty(composition);
            ensureNoDoping(doping);
            return plask::make_shared<MaterialType>();
        }
 
        bool isAlloy() const override { return false; }
    };
 
    class PLASK_API ProxyMaterialConstructor: public MaterialConstructor {
        shared_ptr<Material> material;
        shared_ptr<const MaterialsDB::MaterialConstructor> constructor;
        Material::Composition composition;
        double doping;
 
      public:
        ProxyMaterialConstructor();
 
        ProxyMaterialConstructor(const std::string& name, const MaterialsDB& db=MaterialsDB::getDefault());
 
        ProxyMaterialConstructor(const shared_ptr<Material>& material);
 
        shared_ptr<Material> operator()(const Material::Composition& comp, double dop) const override;
 
        bool isAlloy() const override;
    };
 
    shared_ptr<Material> get(const Material::Composition& composition, const std::string& label, const std::string& dopant_name = "", double doping = 0.0) const;
 
    //shared_ptr<Material> get(const std::string& parsed_name_with_dopant, const std::vector<double>& composition, double doping = 0.) const;
 
    shared_ptr<Material> get(const std::string& name_with_dopant, double doping) const;
 
    /*
     * Create material object.
     * @param name_with_components objects composition in format object1(amount1)...objectN(amountN), where some amounts are optional for example: "Al(0.7)GaN"
     * @param doping_descr empty string if there is no doping or description of dopant in format objectname=amount or objectname p/n=amount, for example: "Mg=7e18" or "Mg p=7e18"
     * @return constructed material
     * @throw NoSuchMaterial if database doesn't know material with name @p parsed_name_with_donor
     * @throw MaterialParseException if can't parse @p name_with_components or @p doping_descr
     */
    //shared_ptr<Material> get(const std::string& name_with_components, const std::string& doping_descr) const;
 
    shared_ptr<const MaterialConstructor> getConstructor(const std::string& name_without_composition) const;
 
    shared_ptr<Material> get(const Material::Parameters& param) const;
 
    shared_ptr<Material> get(const std::string& full_name) const;
 
    shared_ptr<MixedCompositionFactory> getFactory(const std::string& material1_fullname, const std::string& material2_fullname, double shape=1.) const;
 
    /*
     * Add simple material (which does snot require composition parsing) to DB. Replace existing material if there is one already in DB.
     * @param constructor object which can create material instance; must be created by operator new and material DB will call delete for it
     */
   // void addSimple(const MaterialConstructor* constructor);
 
    void addSimple(shared_ptr<MaterialConstructor> constructor);
 
    /*
     * Add alloy material (which require composition parsing) to DB. Replace existing material if there is one already in DB.
     * @param constructor object which can create material instance; must be created by operator new and material DB will call delete for it
     */
    //void addAlloy(const MaterialConstructor* constructor);
 
    void addAlloy(shared_ptr<MaterialConstructor> constructor);
 
    template <typename MaterialType, bool requireComposition, bool requireDopant>
    void add(const std::string& name) {
        if (requireComposition)
            addAlloy(plask::make_shared< DelegateMaterialConstructor<MaterialType, requireComposition, requireDopant> >(name));
        else
            addSimple(plask::make_shared< DelegateMaterialConstructor<MaterialType, requireComposition, requireDopant> >(name));
    }
 
    template <typename MaterialType>
    void add(const std::string& name) {
        add<MaterialType, Material::is_with_composition<MaterialType>::value, Material::is_with_dopant<MaterialType>::value>(name);
    }
 
    template <typename MaterialType>
    void add() { add<MaterialType>(MaterialType::NAME); }
 
    void remove(const std::string& name);
 
    bool isAlloy(const std::string& material_name) const;
 
    /*
     * Get alloy material constructor object.
     * @param composition objects composition
     * @param dopant_name name of dopant (if any)
     */
    shared_ptr<const MaterialConstructor> getConstructor(const Material::Composition& composition, const std::string& label = "", const std::string& dopant_name = "") const;
 
    shared_ptr<const MaterialConstructor> getConstructor(const Material::Parameters& material, bool allow_alloy_without_composition = false) const;
 
private:
 
    //      * @param dopant_name name of dopant (if any), use for error messages
    shared_ptr<const MaterialConstructor> getConstructor(const std::string& dbKey, const Material::Composition& composition, bool allow_alloy_without_composition = false) const;
 
    //      * @param dopant_name name of dopant (if any)
    shared_ptr<Material> get(const std::string& dbKey, const Material::Composition& composition, double doping = 0.0) const;
 
};
 
struct PLASK_API MaterialsDB::TemporaryReplaceDefault {
    MaterialsDB toRevert;
 
    TemporaryReplaceDefault(const TemporaryReplaceDefault&) = delete;
    TemporaryReplaceDefault& operator=(const TemporaryReplaceDefault&) = delete;
    TemporaryReplaceDefault(TemporaryReplaceDefault&&) = delete;
    TemporaryReplaceDefault& operator=(TemporaryReplaceDefault&&) = delete;
 
    TemporaryReplaceDefault(MaterialsDB temporaryValue = MaterialsDB()): toRevert(std::move(getDefault())) {
        getDefault() = std::move(temporaryValue);
    }
 
    ~TemporaryReplaceDefault() {
        MaterialsDB::getDefault() = std::move(toRevert);
    }
};
 
}   // namespace plask
 
#endif // PLASK__MATERIAL_DB_H