info.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_INFO_H
#define PLASK__MATERIAL_INFO_H
 
#include <string>
#include <map>
#include <vector>
#include <utility>
 
#include <boost/tokenizer.hpp>
 
#include "../optional.hpp"
 
#include <plask/config.hpp>   // for PLASK_API
 
namespace plask {
 
struct PLASK_API MaterialInfo {
 
    enum PROPERTY_NAME {
        kind,       
        lattC,      
        Eg,         
        CB,         
        VB,         
        Dso,        
        Mso,        
        Me,         
        Mhh,        
        Mlh,        
        Mh,         
        ac,         
        av,         
        b,          
        d,          
        c11,        
        c12,        
        c44,        
        eps,        
        Eps,         
        chi,        
        Na,         
        Nd,         
        Ni,         
        Nf,         
        EactD,      
        EactA,      
        mob,        
        cond,       
        condtype,   
        A,          
        B,          
        C,          
        D,          
        thermk,     
        dens,       
        cp,         
        nr,         
        absp,       
        Nr,         
        mobe,       
        mobh,       
        taue,       
        tauh,       
        Ce,         
        Ch,         
        e13,        
        e15,        
        e33,        
        c13,        
        c33,        
        Psp,        
        y1,         
        y2,         
        y3          
    };
 
    static const char* PROPERTY_NAME_STRING[55];
 
    static PROPERTY_NAME parsePropertyName(const std::string& name);
 
    enum ARGUMENT_NAME {
        T,          
        e,          
        lam,        
        n,          
        h,          
        doping,     
        point       
    };
 
    static const char* ARGUMENT_NAME_STRING[7];
 
    static ARGUMENT_NAME parseArgumentName(const std::string& name);
 
    struct PLASK_API Link {
        std::string className;
        PROPERTY_NAME property;
        std::string note;
 
        Link(std::string className, PROPERTY_NAME property, std::string note = std::string())
            : className(className), property(property), note(note) {}
 
        Link(const std::string& to_parse);
 
        std::string str() const;
    };
 
    class PLASK_API PropertyInfo {
 
        std::string _info;
 
        PropertyInfo& add(const std::string& infoToAdd) {
            if (_info.empty()) _info = infoToAdd; else (_info += '\n') += infoToAdd;
            return *this;
        }
 
    public:
 
        boost::tokenizer<boost::char_separator<char>> eachLine() const;
 
        std::vector<std::string> eachOfType(const std::string& type) const;
 
        typedef std::pair<double, double> ArgumentRange;
 
        PropertyInfo(std::string info = ""): _info(std::move(info)) {}
 
        static const ArgumentRange NO_RANGE;
 
        PropertyInfo& set(const std::string& new_info) { this->_info = new_info; return *this; }
 
        const std::string& get() const { return _info; }
 
        std::string getSource() const;
 
        std::string getNote() const;
 
        ArgumentRange getArgumentRange(ARGUMENT_NAME argument) const;
 
        std::vector<Link> getLinks() const;
 
        PropertyInfo& addSource(const std::string& sourceToAdd) {
            return add("source: " + sourceToAdd);
        }
 
        PropertyInfo& addNote(const std::string& sourceToAdd) {
            return add("note: " + sourceToAdd);
        }
 
        PropertyInfo& setArgumentRange(ARGUMENT_NAME argument, ArgumentRange range);
 
        PropertyInfo& setArgumentRange(ARGUMENT_NAME argument, double from, double to) {
            return setArgumentRange(argument, ArgumentRange(from, to));
        }
 
        PropertyInfo& addLink(const Link& link) { return add("see: " + link.str()); }
    };
 
    std::string parent;
 
  private:
    std::map<PROPERTY_NAME, PropertyInfo> propertyInfo;
 
  public:
 
    void override(const MaterialInfo &to_override);
 
    PropertyInfo& operator()(PROPERTY_NAME property);
 
    plask::optional<PropertyInfo> getPropertyInfo(PROPERTY_NAME property) const;
 
    typedef std::map<PROPERTY_NAME, PropertyInfo>::iterator iterator;
 
    typedef std::map<PROPERTY_NAME, PropertyInfo>::const_iterator const_iterator;
 
    iterator begin() { return propertyInfo.begin(); }
 
    const_iterator begin() const { return propertyInfo.begin(); }
 
    iterator end() { return propertyInfo.end(); }
 
    const_iterator end() const { return propertyInfo.end(); }
 
    //const PropertyInfo& operator()(PROPERTY_NAME property) const;
 
    class PLASK_API DB {
 
        std::map<std::string, MaterialInfo> materialInfo;
 
      public:
 
        static DB& getDefault();
 
        void clear() {
            materialInfo.clear();
        }
 
        void update(const DB& src) {
            for (const auto& item: src.materialInfo) {
                materialInfo[item.first] = item.second;
            }
        }
 
        MaterialInfo& add(const std::string& materialName, const std::string& parentMaterial);
 
        MaterialInfo& add(const std::string& materialName);
 
        plask::optional<MaterialInfo> get(const std::string& materialName, bool with_inherited_info = true) const;
 
        plask::optional<MaterialInfo::PropertyInfo> get(const std::string& materialName, PROPERTY_NAME propertyName, bool with_inherited_info = true) const;
 
        typedef std::map<std::string, MaterialInfo>::iterator iterator;
 
        typedef std::map<std::string, MaterialInfo>::const_iterator const_iterator;
 
        iterator begin() { return materialInfo.begin(); }
 
        const_iterator begin() const { return materialInfo.begin(); }
 
        iterator end() { return materialInfo.end(); }
 
        const_iterator end() const { return materialInfo.end(); }
 
    };
 
    class PLASK_API Register {
 
        void set(PropertyInfo&) {}
 
        template <typename Setter1, typename ...Setters>
        void set(PropertyInfo& i, const Setter1& setter1, const Setters&... setters) {
            setter1.set(i);
            set(i, setters...);
        }
 
    public:
        Register(const std::string& materialName, const std::string& parentMaterial) {
            MaterialInfo::DB::getDefault().add(materialName, parentMaterial);
        }
 
        template <typename ...PropertySetters>
        Register(const std::string& materialName, const std::string& parentMaterial, PROPERTY_NAME property, const PropertySetters&... propertySetters) {
            set(MaterialInfo::DB::getDefault().add(materialName, parentMaterial)(property), propertySetters...);
        }
 
        Register(const std::string& materialName) {
            MaterialInfo::DB::getDefault().add(materialName);
        }
 
        template <typename ...PropertySetters>
        Register(const std::string& materialName, PROPERTY_NAME property, const PropertySetters&... propertySetters) {
            set(MaterialInfo::DB::getDefault().add(materialName)(property), propertySetters...);
        }
 
        /*template <typename MaterialType, typename ParentType, typename ...PropertySetters>
        Register(const PropertySetters&... propertySetters) {
            set(MaterialInfo::DB::getDefault().add(MaterialType::NAME, ParentType::NAME), propertySetters...);
        }
 
        template <typename MaterialType, typename ...PropertySetters>
        Register(const PropertySetters&... propertySetters) {
            set(MaterialInfo::DB::getDefault().add(MaterialType::NAME), propertySetters...);
        }*/
 
    };
 
    /*struct RegisterProperty {
 
        PropertyInfo& property;
 
        RegisterProperty(Register& material, PROPERTY_NAME property)
            : property(material(property)) {}
 
        RegisterProperty(std::string& material_name, PROPERTY_NAME property)
            : property(MaterialInfo::DB::getDefault().add(material_name)(property)) {}
 
        template <typename MaterialType>
        RegisterProperty(PROPERTY_NAME property)
            : property(MaterialInfo::DB::getDefault().add(MaterialType::NAME)(property)) {}
 
        RegisterProperty& source(const std::string& source) { property.addSource(source); return *this; }
 
        RegisterProperty& info(const std::string& info) { property.add(info); return *this; }
 
        RegisterProperty& argumentRange(ARGUMENT_NAME argument, PropertyInfo::ArgumentRange range) {
            property.setArgumentRange(argument, range); return *this;
        }
 
        RegisterProperty& argumentRange(ARGUMENT_NAME argument, double from, double to) {
            property.setArgumentRange(argument, from, to); return *this;
        }
 
    };*/
 
};
 
struct MISource {
    std::string value;
    MISource(const std::string& value): value(value) {}
    void set(MaterialInfo::PropertyInfo& p) const { p.addSource(value); }
};
 
struct MINote {
    std::string value;
    MINote(const std::string& value): value(value) {}
    void set(MaterialInfo::PropertyInfo& p) const { p.addNote(value); }
};
 
struct MIArgumentRange {
    MaterialInfo::ARGUMENT_NAME arg; double from, to;
    MIArgumentRange(MaterialInfo::ARGUMENT_NAME arg, double from, double to): arg(arg), from(from), to(to) {}
    void set(MaterialInfo::PropertyInfo& p) const { p.setArgumentRange(arg, from, to); }
};
 
struct MISee {
    MaterialInfo::Link value;
    template<typename ...Args> MISee(Args&&... params): value(std::forward<Args>(params)...) {}
    void set(MaterialInfo::PropertyInfo& p) const { p.addLink(value); }
};
 
template <typename materialClass>
struct MISeeClass {
    MaterialInfo::Link value;
    template<typename ...Args> MISeeClass(Args&&... params): value(materialClass::NAME, std::forward<Args>(params)...) {}
    void set(MaterialInfo::PropertyInfo& p) const { p.addLink(value); }
};
 
}
 
#define MI_PARENT(material, parent) static plask::MaterialInfo::Register __materialinfo__parent__  ## material(material::NAME, parent::NAME);
#define MI_PROPERTY(material, property, ...) static plask::MaterialInfo::Register __materialinfo__property__ ## material ## property(material::NAME, plask::MaterialInfo::property, ##__VA_ARGS__);
#define MI_PARENT_PROPERTY(material, parent, property, ...) static plask::MaterialInfo::Register __materialinfo__parent__property__ ## material ## property(material::NAME, parent::NAME, plask::MaterialInfo::property, ##__VA_ARGS__);
 
#endif // PLASK__MATERIAL_INFO_H