ferminew.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__SOLVER_GAIN_FermiNew_H
#define PLASK__SOLVER_GAIN_FermiNew_H
 
#include <plask/plask.hpp>
#include "wzmocnienie/kublybr.h"
 
namespace plask { namespace solvers { namespace FermiNew {
 
template <typename GeometryT, typename T> struct DataBase;
template <typename GeometryT> struct GainData;
template <typename GeometryT> struct DgDnData;
template <typename GeometryT> struct LuminescenceData;
 
template <typename GeometryT> struct GainSpectrum;
template <typename GeometryT> struct LuminescenceSpectrum;
 
struct Levels {
    double Eg;
    std::unique_ptr<kubly::struktura> bandsEc, bandsEvhh, bandsEvlh;
    std::unique_ptr<kubly::struktura> modbandsEc, modbandsEvhh, modbandsEvlh;
    plask::shared_ptr<kubly::obszar_aktywny> activeRegion;
    operator bool() const { return bool(bandsEc) || bool(bandsEvhh) || bool(bandsEvlh); }
};
 
template <typename GeometryType> struct PLASK_SOLVER_API FermiNewGainSolver : public SolverWithMesh<GeometryType, MeshAxis> {
    struct ActiveRegionData {
        shared_ptr<StackContainer<2>> layers;  
        Vec<2> origin;                         
        std::set<int> QWs;
 
        // LUKASZ
        std::vector<double> lens;  
 
        // shared_ptr<Material> materialQW;        ///< Quantum well material
        // shared_ptr<Material> materialBarrier;   ///< Barrier material
        double qwlen;       
        double qwtotallen;  
        double totallen;    
 
        ActiveRegionData(Vec<2> origin) : layers(plask::make_shared<StackContainer<2>>()), origin(origin) {}
 
        size_t size() const { return layers->getChildrenCount(); }
 
        shared_ptr<Material> getLayerMaterial(size_t n) const {
            auto block = static_cast<Block<2>*>(static_cast<Translation<2>*>(layers->getChildNo(n).get())->getChild().get());
            if (auto m = block->singleMaterial()) return m;
            throw plask::Exception("FermiNewGainSolver requires solid layers.");
        }
 
        Box2D getLayerBox(size_t n) const {
            return static_cast<GeometryObjectD<2>*>(layers->getChildNo(n).get())->getBoundingBox() + origin;
        }
 
        bool isQW(size_t n) const { return static_cast<Translation<2>*>(layers->getChildNo(n).get())->getChild()->hasRole("QW"); }
 
        Box2D getBoundingBox() const { return layers->getBoundingBox() + origin; }
 
        bool contains(const Vec<2>& point) const { return getBoundingBox().contains(point); }
 
        bool inQW(const Vec<2>& point) const {
            if (!contains(point)) return false;
            assert(layers->getChildForHeight(point.c1 - origin.c1));
            return layers->getChildForHeight(point.c1 - origin.c1)->getChild()->hasRole("QW");
        }
 
        void summarize(const FermiNewGainSolver<GeometryType>* solver) {
            totallen =
                1e4 * (layers->getBoundingBox().height() -
                       static_pointer_cast<GeometryObjectD<GeometryType::DIM>>(layers->getChildNo(0))->getBoundingBox().height() -
                       static_pointer_cast<GeometryObjectD<GeometryType::DIM>>(layers->getChildNo(layers->getChildrenCount() - 1))
                           ->getBoundingBox()
                           .height());  // 1e4: µm -> Å
            size_t qwn = 0;
            qwtotallen = 0.;
            bool lastbarrier = true;
            for (const auto& layer : layers->children) {
                auto block = static_cast<Block<2>*>(static_cast<Translation<2>*>(layer.get())->getChild().get());
                auto material = block->singleMaterial();
                if (!material) throw plask::Exception("FermiNewGainSolver requires solid layers.");
                if (static_cast<Translation<2>*>(layer.get())->getChild()->hasRole("QW")) {
                    /*if (!materialQW)
                        materialQW = material;
                    else if (*material != *materialQW)
                        throw Exception("{0}: Multiple quantum well materials in active region.", solver->getId());*/
                    auto bbox = static_cast<GeometryObjectD<2>*>(layer.get())->getBoundingBox();
                    qwtotallen += bbox.upper[1] - bbox.lower[1];
                    if (lastbarrier)
                        ++qwn;
                    else
                        solver->writelog(LOG_WARNING, "Considering two adjacent quantum wells as one");
                    lastbarrier = false;
                } else  // if (static_cast<Translation<2>*>(layer.get())->getChild()->hasRole("barrier")) //
                        // TODO 4.09.2014
                {
                    /*if (!materialBarrier)
                        materialBarrier = material;
                    else if (!is_zero(material->Me(300).c00 - materialBarrier->Me(300).c00) ||
                             !is_zero(material->Me(300).c11 - materialBarrier->Me(300).c11) ||
                             !is_zero(material->Mhh(300).c00 - materialBarrier->Mhh(300).c00) ||
                             !is_zero(material->Mhh(300).c11 - materialBarrier->Mhh(300).c11) ||
                             !is_zero(material->Mlh(300).c00 - materialBarrier->Mlh(300).c00) ||
                             !is_zero(material->Mlh(300).c11 - materialBarrier->Mlh(300).c11) ||
                             !is_zero(material->CB(300) - materialBarrier->CB(300)) ||
                             !is_zero(material->VB(300) - materialBarrier->VB(300)))
                        throw Exception("{0}: Multiple barrier materials around active region.", solver->getId());*/
                    lastbarrier = true;
                }  // TODO something must be added here because of spacers placed next to external barriers
            }
            qwtotallen *= 1e4;  // µm -> Å
            qwlen = qwtotallen / qwn;
        }
    };
 
    struct ActiveRegionInfo : public ActiveRegionData {
        boost::optional<ActiveRegionData> mod;  
 
        ActiveRegionInfo(Vec<2> origin) : ActiveRegionData(origin) {}
 
        ActiveRegionInfo(const ActiveRegionData& src) : ActiveRegionData(src) {}
 
        ActiveRegionInfo(ActiveRegionData&& src) : ActiveRegionData(std::move(src)) {}
    };
 
    shared_ptr<GeometryType> geometry_mod;  
 
    shared_ptr<Material> substrateMaterial;  
    bool explicitSubstrate = false;          
 
    std::vector<ActiveRegionInfo> regions;
 
    ReceiverFor<Temperature, GeometryType> inTemperature;
 
    ReceiverFor<CarriersConcentration, GeometryType> inCarriersConcentration;
 
    typename ProviderFor<Gain, GeometryType>::Delegate outGain;
 
    typename ProviderFor<Luminescence, GeometryType>::Delegate outLuminescence;
 
    FermiNewGainSolver(const std::string& name = "");
 
    virtual ~FermiNewGainSolver();
 
    virtual std::string getClassName() const;
 
    virtual void loadConfiguration(plask::XMLReader& reader, plask::Manager& manager);
 
    shared_ptr<GeometryType> getModGeometry() const { return geometry_mod; }
 
    void setModGeometry(const shared_ptr<GeometryType>& geometry) {
        if (geometry == this->geometry_mod) return;
        writelog(LOG_INFO, "Attaching modified geometry to solver");
        disconnectModGeometry();
        this->geometry_mod = geometry;
        if (this->geometry_mod)
            this->geometry_mod->changedConnectMethod(this, &FermiNewGainSolver<GeometryType>::onModGeometryChange);
        onModGeometryChange(Geometry::Event(geometry.get(), 0));
    }
 
    void disconnectModGeometry() {
        if (this->geometry_mod)
            this->geometry_mod->changedDisconnectMethod(this, &FermiNewGainSolver<GeometryType>::onModGeometryChange);
    }
 
    friend struct DataBase<GeometryType, Tensor2<double>>;
    friend struct DataBase<GeometryType, double>;
    friend struct GainData<GeometryType>;
    friend struct DgDnData<GeometryType>;
    friend struct LuminescenceData<GeometryType>;
 
    std::vector<Levels> region_levels;
 
    friend struct GainSpectrum<GeometryType>;
    friend struct LuminescenceSpectrum<GeometryType>;
    friend class wzmocnienie;
 
    double condQWshift;         
    double valeQWshift;         
    double QWwidthMod;          
    double roughness;           
    double lifetime;            
    double matrixElem;          
    double differenceQuotient;  
    double Tref;                
 
    void findEnergyLevels(Levels& levels, const ActiveRegionInfo& region, double T);
 
    void buildStructure(double T,
                        const ActiveRegionData& region,
                        std::unique_ptr<kubly::struktura>& bandsEc,
                        std::unique_ptr<kubly::struktura>& bandsEvhh,
                        std::unique_ptr<kubly::struktura>& bandsEvlh);
    kubly::struktura* buildEc(double T, const ActiveRegionData& region);
    kubly::struktura* buildEvhh(double T, const ActiveRegionData& region);
    kubly::struktura* buildEvlh(double T, const ActiveRegionData& region);
 
    void showEnergyLevels(std::string str, const std::unique_ptr<kubly::struktura>& structure, double nQW);
 
    kubly::wzmocnienie getGainModule(double wavelength, double T, double n, const ActiveRegionInfo& region, const Levels& levels);
 
    void prepareLevels(kubly::wzmocnienie& gmodule, const ActiveRegionInfo& region) {}
 
    virtual void onInitialize();
 
    virtual void onInvalidate();
 
    void onModGeometryChange(const Geometry::Event&) { this->invalidate(); }
 
    void onInputChange(ReceiverBase&, ReceiverBase::ChangeReason) {
        outGain.fireChanged();          // the input changed, so we inform the world that everybody should get the new gain
        outLuminescence.fireChanged();  // the input changed, so we inform the world that everybody should get the new luminescence
    }
 
    std::list<ActiveRegionData> detectActiveRegions(const shared_ptr<GeometryType>& geometry);
 
    void prepareActiveRegionsInfo();
 
    const LazyData<Tensor2<double>> getGain(Gain::EnumType what,
                                            const shared_ptr<const MeshD<2>>& dst_mesh,
                                            double wavelength,
                                            InterpolationMethod interp = INTERPOLATION_DEFAULT);
 
    const LazyData<Tensor2<double>> getLuminescence(const shared_ptr<const MeshD<2>>& dst_mesh,
                                                    double wavelength,
                                                    InterpolationMethod interp = INTERPOLATION_DEFAULT);
 
    bool strains;            
    bool adjust_widths;      
    bool build_struct_once;  
 
  public:
    bool getStrains() const { return strains; }
    void setStrains(bool value) {
        if (strains != value) {
            strains = value;
            if (build_struct_once) this->invalidate();
        }
    }
 
    shared_ptr<Material> getSubstrate() const { return substrateMaterial; }
    void setSubstrate(shared_ptr<Material> material) {
        bool invalid = substrateMaterial != material;
        substrateMaterial = material;
        explicitSubstrate = bool(material);
        if (invalid) this->invalidate();
    }
 
    bool getAdjustWidths() const { return adjust_widths; }
    void setAdjustWidths(bool value) {
        if (adjust_widths != value) {
            adjust_widths = value;
            this->invalidate();
        }
    }
 
    bool getBuildStructOnce() const { return build_struct_once; }
    void setBuildStructOnce(bool value) {
        if (build_struct_once != value) {
            build_struct_once = value;
            this->invalidate();
        }
    }
 
    double getRoughness() const { return roughness; }
    void setRoughness(double value) {
        if (roughness != value) {
            roughness = value;
            if (build_struct_once) this->invalidate();
        }
    }
 
    double getLifeTime() const { return lifetime; }
    void setLifeTime(double value) {
        if (lifetime != value) {
            lifetime = value;
            // if (build_struct_once) this->invalidate();
        }
    }
 
    double getMatrixElem() const { return matrixElem; }
    void setMatrixElem(double value) {
        if (matrixElem != value) {
            matrixElem = value;
            if (build_struct_once) this->invalidate();
        }
    }
 
    double getCondQWShift() const { return condQWshift; }
    void setCondQWShift(double value) {
        if (condQWshift != value) {
            condQWshift = value;
            if (build_struct_once) this->invalidate();
        }
    }
 
    double getValeQWShift() const { return valeQWshift; }
    void setValeQWShift(double value) {
        if (valeQWshift != value) {
            valeQWshift = value;
            if (build_struct_once) this->invalidate();
        }
    }
 
    double getTref() const { return Tref; }
    void setTref(double value) {
        if (Tref != value) {
            Tref = value;
            if (build_struct_once) this->invalidate();
        }
    }
 
    GainSpectrum<GeometryType> getGainSpectrum(const Vec<2>& point);
 
    LuminescenceSpectrum<GeometryType> getLuminescenceSpectrum(const Vec<2>& point);
};
 
template <typename GeometryT> struct PLASK_SOLVER_API GainSpectrum {
    FermiNewGainSolver<GeometryT>* solver;  
    Vec<2> point;                           
 
    size_t reg;
 
    double T;                   
    double n;                   
    unique_ptr<Levels> levels;  
    std::unique_ptr<kubly::wzmocnienie> gMod;
 
    GainSpectrum(FermiNewGainSolver<GeometryT>* solver, const Vec<2> point);
 
    GainSpectrum(const GainSpectrum& orig) : solver(orig.solver), point(orig.point), reg(orig.reg), T(orig.T), n(orig.n) {}
 
    GainSpectrum(GainSpectrum&& orig) = default;
 
    void onTChange(ReceiverBase&, ReceiverBase::ChangeReason) {
        T = solver->inTemperature(plask::make_shared<const OnePointMesh<2>>(point))[0];
    }
 
    void onNChange(ReceiverBase&, ReceiverBase::ChangeReason) {
        n = solver->inCarriersConcentration(plask::make_shared<const OnePointMesh<2>>(point))[0];
    }
 
    ~GainSpectrum() {
        solver->inTemperature.changedDisconnectMethod(this, &GainSpectrum::onTChange);
        solver->inCarriersConcentration.changedDisconnectMethod(this, &GainSpectrum::onNChange);
    }
 
    Tensor2<double> getGain(double wavelength);
};
 
template <typename GeometryT> struct PLASK_SOLVER_API LuminescenceSpectrum {
    FermiNewGainSolver<GeometryT>* solver;  
    Vec<2> point;                           
 
    size_t reg;
 
    double T;                   
    double n;                   
    unique_ptr<Levels> levels;  
    std::unique_ptr<kubly::wzmocnienie> gMod;
 
    LuminescenceSpectrum(FermiNewGainSolver<GeometryT>* solver, const Vec<2> point);
 
    LuminescenceSpectrum(const LuminescenceSpectrum& orig)
        : solver(orig.solver), point(orig.point), reg(orig.reg), T(orig.T), n(orig.n) {}
 
    LuminescenceSpectrum(LuminescenceSpectrum&& orig) = default;
 
    void onTChange(ReceiverBase&, ReceiverBase::ChangeReason) {
        T = solver->inTemperature(plask::make_shared<const OnePointMesh<2>>(point))[0];
    }
 
    void onNChange(ReceiverBase&, ReceiverBase::ChangeReason) {
        n = solver->inCarriersConcentration(plask::make_shared<const OnePointMesh<2>>(point))[0];
    }
 
    ~LuminescenceSpectrum() {
        solver->inTemperature.changedDisconnectMethod(this, &LuminescenceSpectrum::onTChange);
        solver->inCarriersConcentration.changedDisconnectMethod(this, &LuminescenceSpectrum::onNChange);
    }
 
    Tensor2<double> getLuminescence(double wavelength);
};
 
}}}  // namespace plask::solvers::FermiNew
 
#endif