generator_rectangular.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__GENERATOR_RECTANGULAR_H
#define PLASK__GENERATOR_RECTANGULAR_H
 
#include "mesh.hpp"
#include "plask/geometry/path.hpp"
#include "rectangular.hpp"
 
namespace plask {
 
template <int dim>
PLASK_API shared_ptr<OrderedAxis> makeGeometryAxis(const shared_ptr<GeometryObjectD<dim>>& geometry,
                                                   Primitive<3>::Direction dir,
                                                   double split = 0.);
 
PLASK_API shared_ptr<OrderedAxis> makeGeometryGrid1D(const shared_ptr<GeometryObjectD<2>>& geometry, double split = 0.);
 
PLASK_API shared_ptr<RectangularMesh<2>> makeGeometryGrid(const shared_ptr<GeometryObjectD<2>>& geometry, double split = 0.);
 
PLASK_API shared_ptr<RectangularMesh<3>> makeGeometryGrid(const shared_ptr<GeometryObjectD<3>>& geometry, double split = 0.);
 
inline shared_ptr<OrderedAxis> makeGeometryGrid1D(const shared_ptr<GeometryD<2>>& geometry) {
    return makeGeometryGrid1D(geometry->getChild());
}
 
inline shared_ptr<RectangularMesh<2>> makeGeometryGrid(const shared_ptr<GeometryD<2>>& geometry) {
    return makeGeometryGrid(geometry->getChild());
}
 
inline shared_ptr<RectangularMesh<3>> makeGeometryGrid(const shared_ptr<GeometryD<3>>& geometry) {
    return makeGeometryGrid(geometry->getChild());
}
 
PLASK_API shared_ptr<OrderedAxis> refineAxis(const shared_ptr<MeshAxis>& axis, double spacing);
 
struct PLASK_API OrderedMesh1DSimpleGenerator : public MeshGeneratorD<1> {
  protected:
    bool split;
 
  public:
    OrderedMesh1DSimpleGenerator(bool split = false) : split(split) {}
 
    shared_ptr<MeshD<1>> generate(const shared_ptr<GeometryObjectD<2>>& geometry) override;
};
 
struct PLASK_API RectangularMesh2DSimpleGenerator : public MeshGeneratorD<2> {
  protected:
    bool split;
 
  public:
    RectangularMesh2DSimpleGenerator(bool split = false) : split(split) {}
 
    shared_ptr<MeshD<2>> generate(const shared_ptr<GeometryObjectD<2>>& geometry) override;
};
 
struct PLASK_API RectangularMesh3DSimpleGenerator : public MeshGeneratorD<3> {
  protected:
    bool split;
 
  public:
    RectangularMesh3DSimpleGenerator(bool split = false) : split(split) {}
 
    shared_ptr<MeshD<3>> generate(const shared_ptr<GeometryObjectD<3>>& geometry) override;
};
 
class PLASK_API OrderedMesh1DRegularGenerator : public OrderedMesh1DSimpleGenerator {
    double spacing;
 
  public:
    OrderedMesh1DRegularGenerator(double spacing, bool split = false) : OrderedMesh1DSimpleGenerator(split), spacing(spacing) {}
 
    shared_ptr<MeshD<1>> generate(const shared_ptr<GeometryObjectD<2>>& geometry) override;
};
 
class PLASK_API RectangularMesh2DRegularGenerator : public RectangularMesh2DSimpleGenerator {
    double spacing0, spacing1;
 
  public:
    RectangularMesh2DRegularGenerator(double spacing, bool split = false)
        : RectangularMesh2DSimpleGenerator(split), spacing0(spacing), spacing1(spacing) {}
 
    RectangularMesh2DRegularGenerator(double spacing0, double spacing1, bool split = false)
        : RectangularMesh2DSimpleGenerator(split), spacing0(spacing0), spacing1(spacing1) {}
 
    shared_ptr<MeshD<2>> generate(const shared_ptr<GeometryObjectD<2>>& geometry) override;
};
 
struct PLASK_API RectangularMesh3DRegularGenerator : public RectangularMesh3DSimpleGenerator {
    double spacing0, spacing1, spacing2;
 
  public:
    RectangularMesh3DRegularGenerator(double spacing, bool split = false)
        : RectangularMesh3DSimpleGenerator(split), spacing0(spacing), spacing1(spacing), spacing2(spacing) {}
 
    RectangularMesh3DRegularGenerator(double spacing0, double spacing1, double spacing2, bool split = false)
        : RectangularMesh3DSimpleGenerator(split), spacing0(spacing0), spacing1(spacing1), spacing2(spacing2) {}
 
    shared_ptr<MeshD<3>> generate(const shared_ptr<GeometryObjectD<3>>& geometry) override;
};
 
class PLASK_API RectangularMesh2DFrom1DGenerator : public MeshGeneratorD<2> {
    shared_ptr<MeshGeneratorD<1>> horizontal_generator;
 
  public:
    RectangularMesh2DFrom1DGenerator(const shared_ptr<MeshGeneratorD<1>>& source) : horizontal_generator(source) {}
 
    shared_ptr<MeshD<2>> generate(const shared_ptr<GeometryObjectD<2>>& geometry) override;
};
 
template <int dim> struct PLASK_API RectangularMeshRefinedGenerator : public MeshGeneratorD<dim> {
    typedef typename Rectangular_t<dim>::Rectilinear GeneratedMeshType;
    using MeshGeneratorD<dim>::DIM;
 
    typedef std::map<std::pair<weak_ptr<const GeometryObjectD<DIM>>, PathHints>, std::set<double>> Refinements;
 
    double aspect;
 
    Refinements refinements[dim];
 
    shared_ptr<OrderedAxis> getAxis(shared_ptr<OrderedAxis> axis, const shared_ptr<GeometryObjectD<DIM>>& geometry, size_t dir);
 
    virtual shared_ptr<OrderedAxis> processAxis(shared_ptr<OrderedAxis> axis,
                                                const shared_ptr<GeometryObjectD<DIM>>& geometry,
                                                size_t dir) = 0;
 
    virtual const char* name() = 0;
 
    void fromXML(XMLReader&, Manager&);
 
    std::pair<double, double> getMinMax(const shared_ptr<OrderedAxis>& axis);
 
    void divideLargestSegment(shared_ptr<OrderedAxis> axis);
 
    RectangularMeshRefinedGenerator() : aspect(0) {}
 
    shared_ptr<MeshD<dim>> generate(const shared_ptr<GeometryObjectD<DIM>>& geometry) override;
 
    double getAspect() const { return aspect; }
 
    void setAspect(double value) {
        if (value != 0. && value < 2.) throw BadInput("divideGenerator", "maximum aspect must be larger than 2");
        aspect = value;
        this->fireChanged();
    }
 
    const Refinements& getRefinements(typename Primitive<DIM>::Direction direction) const {
        assert(size_t(direction) <= dim);
        return refinements[size_t(direction)];
    }
 
    void addRefinement(typename Primitive<DIM>::Direction direction,
                       const weak_ptr<const GeometryObjectD<DIM>>& object,
                       const PathHints& path,
                       double position) {
        auto key = std::make_pair(object, path);
        assert(size_t(direction) <= dim);
        refinements[size_t(direction)][key].insert(position);
        this->fireChanged();
    }
 
    void addRefinement(typename Primitive<DIM>::Direction direction,
                       const weak_ptr<const GeometryObjectD<DIM>>& object,
                       double position) {
        addRefinement(direction, object, PathHints(), position);
    }
 
    void addRefinement(typename Primitive<DIM>::Direction direction, const Path& path, double position) {
        addRefinement(direction, dynamic_pointer_cast<const GeometryObjectD<DIM>>(path.back()), PathHints(path), position);
    }
 
    void addRefinement(typename Primitive<DIM>::Direction direction, const GeometryObject::Subtree& subtree, double position) {
        auto path = subtree.getLastPath();
        addRefinement(direction, dynamic_pointer_cast<const GeometryObjectD<DIM>>(path.back()), PathHints(path), position);
    }
 
    void removeRefinement(typename Primitive<DIM>::Direction direction,
                          const weak_ptr<const GeometryObjectD<DIM>>& object,
                          const PathHints& path,
                          double position) {
        auto key = std::make_pair(object, path);
        assert(size_t(direction) <= dim);
        auto ref = refinements[size_t(direction)].find(key);
        if (ref == refinements[size_t(direction)].end())
            throw BadInput("RectangularMeshDivideGenerator", "there are no refinements for specified geometry object.");
        auto oposition = ref->second.find(position);
        if (oposition == ref->second.end())
            throw BadInput("RectangularMeshDivideGenerator", "specified geometry object does not have refinements at {0}.",
                           *oposition);
        ref->second.erase(oposition);
        if (ref->second.empty()) refinements[size_t(direction)].erase(ref);
        this->fireChanged();
    }
 
    void removeRefinement(typename Primitive<DIM>::Direction direction,
                          const weak_ptr<const GeometryObjectD<DIM>>& object,
                          double position) {
        removeRefinement(direction, object, PathHints(), position);
    }
 
    void removeRefinement(typename Primitive<DIM>::Direction direction, const Path& path, double position) {
        removeRefinement(direction, dynamic_pointer_cast<const GeometryObjectD<DIM>>(path.back()), PathHints(path), position);
    }
 
    void removeRefinement(typename Primitive<DIM>::Direction direction, const GeometryObject::Subtree& subtree, double position) {
        auto path = subtree.getLastPath();
        removeRefinement(direction, dynamic_pointer_cast<const GeometryObjectD<DIM>>(path.back()), PathHints(path), position);
    }
 
    void removeRefinements(const weak_ptr<const GeometryObjectD<DIM>>& object, const PathHints& path = PathHints()) {
        auto key = std::make_pair(object, path);
        bool found = false;
        for (size_t i = 0; i != dim; ++i) {
            auto ref = refinements[i].find(key);
            if (ref != refinements[i].end()) {
                found = true;
                refinements[i].erase(ref);
            }
        }
        if (found)
            this->fireChanged();
        else
            writelog(LOG_WARNING, "RectangularMeshDivideGenerator: There are no refinements for specified geometry object");
    }
 
    void clearRefinements() {
        refinements[0].clear();
        refinements[1].clear();
        this->fireChanged();
    }
 
    void removeRefinements(const Path& path) {
        removeRefinements(dynamic_pointer_cast<const GeometryObjectD<DIM>>(path.back()), PathHints(path));
    }
 
    void removeRefinements(const GeometryObject::Subtree& subtree) {
        auto path = subtree.getLastPath();
        removeRefinements(dynamic_pointer_cast<const GeometryObjectD<DIM>>(path.back()), PathHints(path));
    }
};
 
template <>
shared_ptr<MeshD<1>> RectangularMeshRefinedGenerator<1>::generate(const boost::shared_ptr<plask::GeometryObjectD<2>>& geometry);
template <>
shared_ptr<MeshD<2>> RectangularMeshRefinedGenerator<2>::generate(const boost::shared_ptr<plask::GeometryObjectD<2>>& geometry);
template <>
shared_ptr<MeshD<3>> RectangularMeshRefinedGenerator<3>::generate(const boost::shared_ptr<plask::GeometryObjectD<3>>& geometry);
 
PLASK_API_EXTERN_TEMPLATE_STRUCT(RectangularMeshRefinedGenerator<1>)
PLASK_API_EXTERN_TEMPLATE_STRUCT(RectangularMeshRefinedGenerator<2>)
PLASK_API_EXTERN_TEMPLATE_STRUCT(RectangularMeshRefinedGenerator<3>)
 
 
template <int dim> struct PLASK_API RectangularMeshDivideGenerator : public RectangularMeshRefinedGenerator<dim> {
    typedef typename Rectangular_t<dim>::Rectilinear GeneratedMeshType;
    using MeshGeneratorD<dim>::DIM;
 
    size_t pre_divisions[dim];
    size_t post_divisions[dim];
 
    char gradual;
 
    shared_ptr<OrderedAxis> processAxis(shared_ptr<OrderedAxis> axis,
                                        const shared_ptr<GeometryObjectD<DIM>>& geometry,
                                        size_t dir) override;
 
    const char* name() override { return "DivideGenerator"; }
 
    template <int fd> friend shared_ptr<MeshGenerator> readRectangularDivideGenerator(XMLReader&, Manager&);
 
    RectangularMeshDivideGenerator() : gradual(7) {
        for (int i = 0; i != dim; ++i) {
            pre_divisions[i] = 1;
            post_divisions[i] = 1;
        }
    }
 
    inline size_t getPreDivision(typename Primitive<DIM>::Direction direction) const {
        assert(size_t(direction) <= dim);
        return pre_divisions[size_t(direction)];
    }
 
    inline void setPreDivision(typename Primitive<DIM>::Direction direction, size_t div) {
        assert(size_t(direction) <= dim);
        pre_divisions[size_t(direction)] = div;
        this->fireChanged();
    }
 
    inline size_t getPostDivision(typename Primitive<DIM>::Direction direction) const {
        assert(size_t(direction) <= dim);
        return post_divisions[size_t(direction)];
    }
 
    inline void setPostDivision(typename Primitive<DIM>::Direction direction, size_t div) {
        assert(size_t(direction) <= dim);
        post_divisions[size_t(direction)] = div;
        this->fireChanged();
    }
 
    inline bool getGradual(size_t dir) const {
        assert(dir <= dim);
        return (gradual >> dir) & 1;
    }
 
    inline void setGradual(size_t dir, bool value) {
        assert(dir <= dim);
        gradual &= ~(1 << dir);
        if (value) gradual |= 1 << dir;
        this->fireChanged();
    }
 
    inline bool getGradual(typename Primitive<DIM>::Direction direction) const { return getGradual(size_t(direction)); }
 
    inline void setGradual(typename Primitive<DIM>::Direction direction, bool value) { setGradual(size_t(direction), value); }
};
 
PLASK_API_EXTERN_TEMPLATE_STRUCT(RectangularMeshDivideGenerator<1>)
PLASK_API_EXTERN_TEMPLATE_STRUCT(RectangularMeshDivideGenerator<2>)
PLASK_API_EXTERN_TEMPLATE_STRUCT(RectangularMeshDivideGenerator<3>)
 
 
template <int dim> struct PLASK_API RectangularMeshSmoothGenerator : public RectangularMeshRefinedGenerator<dim> {
    typedef typename Rectangular_t<dim>::Rectilinear GeneratedMeshType;
    using MeshGeneratorD<dim>::DIM;
 
    double finestep[dim];  
    double maxstep[dim];   
    double factor[dim];    
 
    shared_ptr<OrderedAxis> processAxis(shared_ptr<OrderedAxis> axis,
                                        const shared_ptr<GeometryObjectD<DIM>>& geometry,
                                        size_t dir) override;
 
    const char* name() override { return "SmoothGenerator"; }
 
    template <int fd> friend shared_ptr<MeshGenerator> readRectangularSmoothGenerator(XMLReader&, Manager&);
 
    RectangularMeshSmoothGenerator();
 
    inline double getFineStep(typename Primitive<DIM>::Direction direction) const {
        assert(size_t(direction) <= dim);
        return finestep[size_t(direction)];
    }
 
    inline void setFineStep(typename Primitive<DIM>::Direction direction, double value) {
        assert(size_t(direction) <= dim);
        finestep[size_t(direction)] = value;
        this->fireChanged();
    }
 
    inline double getMaxStep(typename Primitive<DIM>::Direction direction) const {
        assert(size_t(direction) <= dim);
        return maxstep[size_t(direction)];
    }
 
    inline void setMaxStep(typename Primitive<DIM>::Direction direction, double value) {
        assert(size_t(direction) <= dim);
        maxstep[size_t(direction)] = value;
        this->fireChanged();
    }
 
    inline double getFactor(typename Primitive<DIM>::Direction direction) const {
        assert(size_t(direction) <= dim);
        return factor[size_t(direction)];
    }
 
    inline void setFactor(typename Primitive<DIM>::Direction direction, double value) {
        assert(size_t(direction) <= dim);
        if (value < 1.)
            throw BadInput("SmoothGenerator", "increase factor for axis {:d} cannot be smaller than 1", size_t(direction));
        factor[size_t(direction)] = value;
        this->fireChanged();
    }
};
 
template <> RectangularMeshSmoothGenerator<1>::RectangularMeshSmoothGenerator();
template <> RectangularMeshSmoothGenerator<2>::RectangularMeshSmoothGenerator();
template <> RectangularMeshSmoothGenerator<3>::RectangularMeshSmoothGenerator();
 
PLASK_API_EXTERN_TEMPLATE_STRUCT(RectangularMeshSmoothGenerator<1>)
PLASK_API_EXTERN_TEMPLATE_STRUCT(RectangularMeshSmoothGenerator<2>)
PLASK_API_EXTERN_TEMPLATE_STRUCT(RectangularMeshSmoothGenerator<3>)
 
}  // namespace plask
 
#endif  // PLASK__GENERATOR_RECTANGULAR_H