rectangular_common.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__MESH__RECTANGULAR_COMMON_H
#define PLASK__MESH__RECTANGULAR_COMMON_H
 
#include "boundary.hpp"
#include "ordered1d.hpp"
#include "../geometry/path.hpp"
#include "../manager.hpp"
 
namespace plask {
 
shared_ptr<MeshAxis> readMeshAxis(XMLReader& reader);
 
namespace details {
 
inline bool getLineLo(std::size_t& line, const MeshAxis& axis, double box_lower, double box_upper) {
    assert(box_lower <= box_upper);
    line = axis.findIndex(box_lower);
    return line != axis.size() && axis[line] <= box_upper;
}
 
inline bool getLineHi(std::size_t& line, const MeshAxis& axis, double box_lower, double box_upper) {
    assert(box_lower <= box_upper);
    line = axis.findIndex(box_upper);
    if (line != axis.size() && axis[line] == box_upper) return true;
    if (line == 0) return false;
    --line;
    return axis[line] >= box_lower;
}
 
inline bool getIndexesInBounds(std::size_t& begInd, std::size_t& endInd, const MeshAxis& axis, double box_lower, double box_upper) {
    if(box_lower > box_upper) return false;
    begInd = axis.findIndex(box_lower);
    endInd = axis.findIndex(box_upper);
    if (endInd != axis.size() && axis[endInd] == box_upper) ++endInd;    // endInd is excluded
    return begInd != endInd;
}
 
inline void tryMakeLower(const MeshAxis& axis, std::size_t& index, double real_pos) {
    if (index == 0) return;
    if ((real_pos - axis[index-1]) * 100.0 < (axis[index] - axis[index-1])) --index;
}
 
inline void tryMakeHigher(const MeshAxis& axis, std::size_t& index, double real_pos) {
    if (index == axis.size() || index == 0) return; //index == 0 means empty mesh
    if ((axis[index] - real_pos) * 100.0 < (axis[index] - axis[index-1])) ++index;
}
 
inline bool getIndexesInBoundsExt(std::size_t& begInd, std::size_t& endInd, const MeshAxis& axis, double box_lower, double box_upper) {
    getIndexesInBounds(begInd, endInd, axis, box_lower, box_upper);
    tryMakeLower(axis, begInd, box_lower);
    tryMakeHigher(axis, endInd, box_upper);
    return begInd != endInd;
}
 
template <typename MeshType, typename GetBoxes, typename GetBoundaryForBox>
inline typename MeshType::Boundary getBoundaryForBoxes(GetBoxes getBoxes, GetBoundaryForBox getBoundaryForBox) {
    return typename MeshType::Boundary(
        [=](const MeshType& mesh, const shared_ptr<const GeometryD<MeshType::DIM>>& geometry) -> BoundaryNodeSet {
            std::vector<typename MeshType::Boundary> boundaries;
            std::vector<BoundaryNodeSet> boundaries_with_meshes;
            auto boxes = getBoxes(geometry); // probably std::vector<BoxdirD>
            for (auto& box: boxes) {
                typename MeshType::Boundary boundary = getBoundaryForBox(box);
                BoundaryNodeSet boundary_with_mesh = boundary(mesh, geometry);
                if (!boundary_with_mesh.empty()) {
                    boundaries.push_back(std::move(boundary));
                    boundaries_with_meshes.push_back(std::move(boundary_with_mesh));
                }
            }
            if (boundaries.empty()) return new EmptyBoundaryImpl();
            if (boundaries.size() == 1) return boundaries_with_meshes[0];
            return new UnionBoundarySetImpl(std::move(boundaries_with_meshes));
        }
    );
}
 
/*struct GetObjectBoundingBoxesCaller {
 
    shared_ptr<const GeometryObject> object;
    std::unique_ptr<PathHints> path;
 
    GetObjectBoundingBoxesCaller(shared_ptr<const GeometryObject> object, const PathHints* path)
        : object(object), path(path ? new PathHints(*path) : nullptr)
    {}
 
    auto operator()(const shared_ptr<const GeometryD<2>>& geometry) const -> decltype(geometry->getObjectBoundingBoxes(object))  {
        return geometry->getObjectBoundingBoxes(object, path.get());
    }
 
    auto operator()(const shared_ptr<const GeometryD<3>>& geometry) const -> decltype(geometry->getObjectBoundingBoxes(object))  {
        return geometry->getObjectBoundingBoxes(object, path.get());
    }
 
};*/
 
template <typename Boundary, int DIM>
inline Boundary parseBoundaryFromXML(XMLReader& boundary_desc, Manager& manager, Boundary (*getXBoundary)(),
                                     Boundary (*getXOfBoundary)(shared_ptr<const GeometryObject>, const PathHints*)) {
    plask::optional<std::string> of = boundary_desc.getAttribute("object");
    if (!of) {
        boundary_desc.requireTagEnd();
        return getXBoundary();
    } else {
        plask::optional<std::string> path_name = boundary_desc.getAttribute("path");
        boundary_desc.requireTagEnd();
        return getXOfBoundary(manager.requireGeometryObject(*of),
                              path_name ? &manager.requirePathHints(*path_name) : nullptr);
    }
}
 
}   // namespace details
 
struct PLASK_API RectangularMeshBase2D: public MeshD<2> {
 
    typedef plask::Boundary<RectangularMeshBase2D> Boundary;
 
    template <typename Predicate>
    static Boundary getBoundary(Predicate predicate) {
        return Boundary(new PredicateBoundaryImpl<RectangularMeshBase2D, Predicate>(predicate));
    }
 
    virtual BoundaryNodeSet createVerticalBoundaryAtLine(std::size_t line_nr_axis0) const = 0;
 
    static Boundary getVerticalBoundaryAtLine(std::size_t line_nr_axis0) {
        return Boundary( [line_nr_axis0](const RectangularMeshBase2D& mesh, const shared_ptr<const GeometryD<2>>&) {
            return mesh.createVerticalBoundaryAtLine(line_nr_axis0);
        } );
    }
 
    virtual BoundaryNodeSet createVerticalBoundaryAtLine(std::size_t line_nr_axis0, std::size_t indexBegin, std::size_t indexEnd) const = 0;
 
    static Boundary getVerticalBoundaryAtLine(std::size_t line_nr_axis0, std::size_t indexBegin, std::size_t indexEnd) {
        return Boundary( [=](const RectangularMeshBase2D& mesh, const shared_ptr<const GeometryD<2>>&) {
            return mesh.createVerticalBoundaryAtLine(line_nr_axis0, indexBegin, indexEnd);
        } );
    }
 
    virtual BoundaryNodeSet createVerticalBoundaryNear(double axis0_coord) const = 0;
 
    static Boundary getVerticalBoundaryNear(double axis0_coord) {
        return Boundary( [axis0_coord](const RectangularMeshBase2D& mesh, const shared_ptr<const GeometryD<2>>&) {
            return mesh.createVerticalBoundaryNear(axis0_coord);
        } );
    }
 
    virtual BoundaryNodeSet createVerticalBoundaryNear(double axis0_coord, double from, double to) const = 0;
 
    static Boundary getVerticalBoundaryNear(double axis0_coord, double from, double to) {
        return Boundary( [axis0_coord, from, to](const RectangularMeshBase2D& mesh, const shared_ptr<const GeometryD<2>>&) {
            return mesh.createVerticalBoundaryNear(axis0_coord, from, to);
        } );
    }
 
    virtual BoundaryNodeSet createLeftBoundary() const = 0;
 
    static Boundary getLeftBoundary() {
        return Boundary( [](const RectangularMeshBase2D& mesh, const shared_ptr<const GeometryD<2>>&) {
            return mesh.createLeftBoundary();
        } );
    }
 
    virtual BoundaryNodeSet createRightBoundary() const = 0;
 
 
    static Boundary getRightBoundary() {
        return Boundary( [](const RectangularMeshBase2D& mesh, const shared_ptr<const GeometryD<2>>&) {
            return mesh.createRightBoundary();
        } );
    }
 
    virtual BoundaryNodeSet createLeftOfBoundary(const Box2D& box) const = 0;
 
    static Boundary getLeftOfBoundary(const Box2D& box) {
        if (!box.isValid()) return makeEmptyBoundary<RectangularMeshBase2D>();
        return Boundary( [=](const RectangularMeshBase2D& mesh, const shared_ptr<const GeometryD<2>>&) {
            return mesh.createLeftOfBoundary(box);
        } );
    }
 
    virtual BoundaryNodeSet createRightOfBoundary(const Box2D& box) const = 0;
 
    static Boundary getRightOfBoundary(const Box2D& box) {
        if (!box.isValid()) return makeEmptyBoundary<RectangularMeshBase2D>();
        return Boundary( [=](const RectangularMeshBase2D& mesh, const shared_ptr<const GeometryD<2>>&) {
            return mesh.createRightOfBoundary(box);
        } );
    }
 
    virtual BoundaryNodeSet createBottomOfBoundary(const Box2D& box) const = 0;
 
    static Boundary getBottomOfBoundary(const Box2D& box) {
        if (!box.isValid()) return makeEmptyBoundary<RectangularMeshBase2D>();
        return Boundary( [=](const RectangularMeshBase2D& mesh, const shared_ptr<const GeometryD<2>>&) {
            return mesh.createBottomOfBoundary(box);
        } );
    }
 
    virtual BoundaryNodeSet createTopOfBoundary(const Box2D& box) const = 0;
 
    static Boundary getTopOfBoundary(const Box2D& box) {
        if (!box.isValid()) return makeEmptyBoundary<RectangularMeshBase2D>();
        return Boundary( [=](const RectangularMeshBase2D& mesh, const shared_ptr<const GeometryD<2>>&) {
            return mesh.createTopOfBoundary(box);
        } );
    }
 
    static Boundary getLeftOfBoundary(shared_ptr<const GeometryObject> object, const PathHints& path) {
        return details::getBoundaryForBoxes< RectangularMeshBase2D >(
            [=](const shared_ptr<const GeometryD<2>>& geometry) { return geometry->getObjectBoundingBoxes(object, path); },
            [](const Box2D& box) { return RectangularMeshBase2D::getLeftOfBoundary(box); }
        );
    }
 
    static Boundary getLeftOfBoundary(shared_ptr<const GeometryObject> object) {
        return details::getBoundaryForBoxes< RectangularMeshBase2D >(
            [=](const shared_ptr<const GeometryD<2>>& geometry) { return geometry->getObjectBoundingBoxes(object); },
            [](const Box2D& box) { return RectangularMeshBase2D::getLeftOfBoundary(box); }
        );
    }
 
    static Boundary getLeftOfBoundary(shared_ptr<const GeometryObject> object, const PathHints* path) {
        return path ? getLeftOfBoundary(object, *path) : getLeftOfBoundary(object);
    }
 
    static Boundary getRightOfBoundary(shared_ptr<const GeometryObject> object, const PathHints& path) {
        return details::getBoundaryForBoxes< RectangularMeshBase2D >(
            [=](const shared_ptr<const GeometryD<2>>& geometry) { return geometry->getObjectBoundingBoxes(object, path); },
            [](const Box2D& box) { return RectangularMeshBase2D::getRightOfBoundary(box); }
        );
    }
 
    static Boundary getRightOfBoundary(shared_ptr<const GeometryObject> object) {
        return details::getBoundaryForBoxes< RectangularMeshBase2D >(
            [=](const shared_ptr<const GeometryD<2>>& geometry) { return geometry->getObjectBoundingBoxes(object); },
            [](const Box2D& box) { return RectangularMeshBase2D::getRightOfBoundary(box); }
        );
    }
 
    static Boundary getRightOfBoundary(shared_ptr<const GeometryObject> object, const PathHints* path) {
        return path ? getRightOfBoundary(object, *path) : getRightOfBoundary(object);
    }
 
    static Boundary getBottomOfBoundary(shared_ptr<const GeometryObject> object, const PathHints& path) {
        return details::getBoundaryForBoxes< RectangularMeshBase2D >(
            [=](const shared_ptr<const GeometryD<2>>& geometry) { return geometry->getObjectBoundingBoxes(object, path); },
            [](const Box2D& box) { return RectangularMeshBase2D::getBottomOfBoundary(box); }
        );
    }
 
    static Boundary getBottomOfBoundary(shared_ptr<const GeometryObject> object) {
        return details::getBoundaryForBoxes< RectangularMeshBase2D >(
            [=](const shared_ptr<const GeometryD<2>>& geometry) { return geometry->getObjectBoundingBoxes(object); },
            [](const Box2D& box) { return RectangularMeshBase2D::getBottomOfBoundary(box); }
        );
    }
 
    static Boundary getBottomOfBoundary(shared_ptr<const GeometryObject> object, const PathHints* path) {
        return path ? getBottomOfBoundary(object, *path) : getBottomOfBoundary(object);
    }
 
    static Boundary getTopOfBoundary(shared_ptr<const GeometryObject> object, const PathHints& path) {
        return details::getBoundaryForBoxes< RectangularMeshBase2D >(
            [=](const shared_ptr<const GeometryD<2>>& geometry) { return geometry->getObjectBoundingBoxes(object, path); },
            [](const Box2D& box) { return RectangularMeshBase2D::getTopOfBoundary(box); }
        );
    }
 
    static Boundary getTopOfBoundary(shared_ptr<const GeometryObject> object) {
        return details::getBoundaryForBoxes< RectangularMeshBase2D >(
            [=](const shared_ptr<const GeometryD<2>>& geometry) { return geometry->getObjectBoundingBoxes(object); },
            [](const Box2D& box) { return RectangularMeshBase2D::getTopOfBoundary(box); }
        );
    }
 
    static Boundary getTopOfBoundary(shared_ptr<const GeometryObject> object, const PathHints* path) {
        return path ? getTopOfBoundary(object, *path) : getTopOfBoundary(object);
    }
 
    virtual BoundaryNodeSet createHorizontalBoundaryAtLine(std::size_t line_nr_axis1) const = 0;
 
    static Boundary getHorizontalBoundaryAtLine(std::size_t line_nr_axis1) {
        return Boundary( [line_nr_axis1](const RectangularMeshBase2D& mesh, const shared_ptr<const GeometryD<2>>&) {
            return mesh.createHorizontalBoundaryAtLine(line_nr_axis1);
        } );
    }
 
    virtual BoundaryNodeSet createHorizontalBoundaryAtLine(std::size_t line_nr_axis1, std::size_t indexBegin, std::size_t indexEnd) const = 0;
 
    static Boundary getHorizontalBoundaryAtLine(std::size_t line_nr_axis1, std::size_t indexBegin, std::size_t indexEnd) {
        return Boundary( [=](const RectangularMeshBase2D& mesh, const shared_ptr<const GeometryD<2>>&) {
            return mesh.createHorizontalBoundaryAtLine(line_nr_axis1, indexBegin, indexEnd);
        } );
    }
 
    virtual BoundaryNodeSet createHorizontalBoundaryNear(double axis1_coord) const = 0;
 
    static Boundary getHorizontalBoundaryNear(double axis1_coord) {
        return Boundary( [axis1_coord](const RectangularMeshBase2D& mesh, const shared_ptr<const GeometryD<2>>&) {
            return mesh.createHorizontalBoundaryNear(axis1_coord);
        } );
    }
 
    virtual BoundaryNodeSet createHorizontalBoundaryNear(double axis1_coord, double from, double to) const = 0;
 
    static Boundary getHorizontalBoundaryNear(double axis1_coord, double from, double to) {
        return Boundary( [axis1_coord, from, to](const RectangularMeshBase2D& mesh, const shared_ptr<const GeometryD<2>>&) {
            return mesh.createHorizontalBoundaryNear(axis1_coord, from, to);
        } );
    }
 
    virtual BoundaryNodeSet createTopBoundary() const = 0;
 
    static Boundary getTopBoundary() {
        return Boundary( [](const RectangularMeshBase2D& mesh, const shared_ptr<const GeometryD<2>>&) {
            return mesh.createTopBoundary();
        } );
    }
 
    virtual BoundaryNodeSet createBottomBoundary() const = 0;
 
    static Boundary getBottomBoundary() {
        return Boundary( [](const RectangularMeshBase2D& mesh, const shared_ptr<const GeometryD<2>>&) {
            return mesh.createBottomBoundary();
        } );
    }
 
    static Boundary getBoundary(const std::string &boundary_desc);
 
    static Boundary getBoundary(XMLReader &boundary_desc, Manager &manager);
 
};
 
template <>
inline RectangularMeshBase2D::Boundary parseBoundary<RectangularMeshBase2D::Boundary>(const std::string& boundary_desc, plask::Manager&) { return RectangularMeshBase2D::getBoundary(boundary_desc); }
 
template <>
inline RectangularMeshBase2D::Boundary parseBoundary<RectangularMeshBase2D::Boundary>(XMLReader& boundary_desc, Manager& env) { return RectangularMeshBase2D::getBoundary(boundary_desc, env); }
 
struct PLASK_API RectangularMeshBase3D: public MeshD<3> {
 
    typedef plask::Boundary<RectangularMeshBase3D> Boundary;
 
    template <typename Predicate>
    static Boundary getBoundary(Predicate predicate) {
        return Boundary(new PredicateBoundaryImpl<RectangularMeshBase3D, Predicate>(predicate));
    }
 
    virtual BoundaryNodeSet createIndex0BoundaryAtLine(std::size_t line_nr_axis0) const = 0;
 
    static Boundary getIndex0BoundaryAtLine(std::size_t line_nr_axis0) {
        return Boundary( [line_nr_axis0](const RectangularMeshBase3D& mesh, const shared_ptr<const GeometryD<3>>&) {
            return mesh.createIndex0BoundaryAtLine(line_nr_axis0);
        } );
    }
 
    virtual BoundaryNodeSet createIndex0BoundaryAtLine(std::size_t line_nr_axis0,
                                                         std::size_t index1Begin, std::size_t index1End,
                                                         std::size_t index2Begin, std::size_t index2End
                                                         ) const = 0;
 
    static Boundary getIndex0BoundaryAtLine(std::size_t line_nr_axis0,
                                            std::size_t index1Begin, std::size_t index1End,
                                            std::size_t index2Begin, std::size_t index2End) {
        return Boundary( [=](const RectangularMeshBase3D& mesh, const shared_ptr<const GeometryD<3>>&) {
            return mesh.createIndex0BoundaryAtLine(line_nr_axis0, index1Begin, index1End, index2Begin, index2End);
        } );
    }
 
    virtual BoundaryNodeSet createIndex1BoundaryAtLine(std::size_t line_nr_axis1) const = 0;
 
    static Boundary getIndex1BoundaryAtLine(std::size_t line_nr_axis1) {
        return Boundary( [line_nr_axis1](const RectangularMeshBase3D& mesh, const shared_ptr<const GeometryD<3>>&) {
            return mesh.createIndex1BoundaryAtLine(line_nr_axis1);
        } );
    }
 
    virtual BoundaryNodeSet createIndex1BoundaryAtLine(std::size_t line_nr_axis1,
                                                         std::size_t index0Begin, std::size_t index0End,
                                                         std::size_t index2Begin, std::size_t index2End
                                                         ) const = 0;
 
    static Boundary getIndex1BoundaryAtLine(std::size_t line_nr_axis1,
                                            std::size_t index0Begin, std::size_t index0End,
                                            std::size_t index2Begin, std::size_t index2End) {
        return Boundary( [=](const RectangularMeshBase3D& mesh, const shared_ptr<const GeometryD<3>>&) {
            return mesh.createIndex1BoundaryAtLine(line_nr_axis1, index0Begin, index0End, index2Begin, index2End);
        } );
    }
 
    virtual BoundaryNodeSet createIndex2BoundaryAtLine(std::size_t line_nr_axis2) const = 0;
 
    static Boundary getIndex2BoundaryAtLine(std::size_t line_nr_axis2) {
        return Boundary( [line_nr_axis2](const RectangularMeshBase3D& mesh, const shared_ptr<const GeometryD<3>>&) {
            return mesh.createIndex2BoundaryAtLine(line_nr_axis2);
        } );
    }
 
    virtual BoundaryNodeSet createIndex2BoundaryAtLine(std::size_t line_nr_axis2,
                                                         std::size_t index0Begin, std::size_t index0End,
                                                         std::size_t index1Begin, std::size_t index1End
                                                         ) const = 0;
 
    static Boundary getIndex2BoundaryAtLine(std::size_t line_nr_axis2,
                                            std::size_t index0Begin, std::size_t index0End,
                                            std::size_t index1Begin, std::size_t index1End) {
        return Boundary( [=](const RectangularMeshBase3D& mesh, const shared_ptr<const GeometryD<3>>&) {
            return mesh.createIndex2BoundaryAtLine(line_nr_axis2, index0Begin, index0End, index1Begin, index1End);
        } );
    }
 
    virtual BoundaryNodeSet createBackBoundary() const = 0;
 
    static Boundary getBackBoundary() {
        return Boundary( [](const RectangularMeshBase3D& mesh, const shared_ptr<const GeometryD<3>>&) {
            return mesh.createBackBoundary();
        } );
    }
 
    virtual BoundaryNodeSet createBackOfBoundary(const Box3D& box) const = 0;
 
    static Boundary getBackOfBoundary(const Box3D& box) {
        if (!box.isValid()) return makeEmptyBoundary<RectangularMeshBase3D>();
        return Boundary( [=](const RectangularMeshBase3D& mesh, const shared_ptr<const GeometryD<3>>&) {
            return mesh.createBackOfBoundary(box);
        } );
    }
 
    virtual BoundaryNodeSet createFrontBoundary() const = 0;
 
    static Boundary getFrontBoundary() {
        return Boundary( [](const RectangularMeshBase3D& mesh, const shared_ptr<const GeometryD<3>>&) {
            return mesh.createFrontBoundary();
        } );
    }
 
    virtual BoundaryNodeSet createFrontOfBoundary(const Box3D& box) const = 0;
 
    static Boundary getFrontOfBoundary(const Box3D& box) {
        if (!box.isValid()) return makeEmptyBoundary<RectangularMeshBase3D>();
        return Boundary( [=](const RectangularMeshBase3D& mesh, const shared_ptr<const GeometryD<3>>&) {
            return mesh.createFrontOfBoundary(box);
        } );
    }
 
    virtual BoundaryNodeSet createLeftBoundary() const = 0;
 
    static Boundary getLeftBoundary() {
        return Boundary( [](const RectangularMeshBase3D& mesh, const shared_ptr<const GeometryD<3>>&) {
            return mesh.createLeftBoundary();
        } );
    }
 
    virtual BoundaryNodeSet createLeftOfBoundary(const Box3D& box) const = 0;
 
    static Boundary getLeftOfBoundary(const Box3D& box) {
        if (!box.isValid()) return makeEmptyBoundary<RectangularMeshBase3D>();
        return Boundary( [=](const RectangularMeshBase3D& mesh, const shared_ptr<const GeometryD<3>>&) {
            return mesh.createLeftOfBoundary(box);
        } );
    }
 
    virtual BoundaryNodeSet createRightBoundary() const = 0;
 
 
    static Boundary getRightBoundary() {
        return Boundary( [](const RectangularMeshBase3D& mesh, const shared_ptr<const GeometryD<3>>&) {
            return mesh.createRightBoundary();
        } );
    }
 
    virtual BoundaryNodeSet createRightOfBoundary(const Box3D& box) const = 0;
 
    static Boundary getRightOfBoundary(const Box3D& box) {
        if (!box.isValid()) return makeEmptyBoundary<RectangularMeshBase3D>();
        return Boundary( [=](const RectangularMeshBase3D& mesh, const shared_ptr<const GeometryD<3>>&) {
            return mesh.createLeftOfBoundary(box);
        } );
    }
 
    virtual BoundaryNodeSet createTopBoundary() const = 0;
 
    static Boundary getTopBoundary() {
        return Boundary( [](const RectangularMeshBase3D& mesh, const shared_ptr<const GeometryD<3>>&) {
            return mesh.createTopBoundary();
        } );
    }
 
    virtual BoundaryNodeSet createTopOfBoundary(const Box3D& box) const = 0;
 
    static Boundary getTopOfBoundary(const Box3D& box) {
        if (!box.isValid()) return makeEmptyBoundary<RectangularMeshBase3D>();
        return Boundary( [=](const RectangularMeshBase3D& mesh, const shared_ptr<const GeometryD<3>>&) {
            return mesh.createTopOfBoundary(box);
        } );
    }
 
    virtual BoundaryNodeSet createBottomBoundary() const = 0;
 
    static Boundary getBottomBoundary() {
        return Boundary( [](const RectangularMeshBase3D& mesh, const shared_ptr<const GeometryD<3>>&) {
            return mesh.createBottomBoundary();
        } );
    }
 
    virtual BoundaryNodeSet createBottomOfBoundary(const Box3D& box) const = 0;
 
    static Boundary getBottomOfBoundary(const Box3D& box) {
        if (!box.isValid()) return makeEmptyBoundary<RectangularMeshBase3D>();
        return Boundary( [=](const RectangularMeshBase3D& mesh, const shared_ptr<const GeometryD<3>>&) {
            return mesh.createBottomOfBoundary(box);
        } );
    }
 
    static Boundary getLeftOfBoundary(shared_ptr<const GeometryObject> object, const PathHints& path) {
        return details::getBoundaryForBoxes< RectangularMeshBase3D >(
            [=](const shared_ptr<const GeometryD<3>>& geometry) { return geometry->getObjectBoundingBoxes(object, path); },
            [](const Box3D& box) { return RectangularMeshBase3D::getLeftOfBoundary(box); }
        );
    }
 
    static Boundary getLeftOfBoundary(shared_ptr<const GeometryObject> object, const PathHints* path) {
        return path ? getLeftOfBoundary(object, *path) : getLeftOfBoundary(object);
    }
 
    static Boundary getLeftOfBoundary(shared_ptr<const GeometryObject> object) {
        return details::getBoundaryForBoxes< RectangularMeshBase3D >(
            [=](const shared_ptr<const GeometryD<3>>& geometry) { return geometry->getObjectBoundingBoxes(object); },
            [](const Box3D& box) { return RectangularMeshBase3D::getLeftOfBoundary(box); }
        );
    }
 
    static Boundary getRightOfBoundary(shared_ptr<const GeometryObject> object, const PathHints& path) {
        return details::getBoundaryForBoxes< RectangularMeshBase3D >(
            [=](const shared_ptr<const GeometryD<3>>& geometry) { return geometry->getObjectBoundingBoxes(object, path); },
            [](const Box3D& box) { return RectangularMeshBase3D::getRightOfBoundary(box); }
        );
    }
 
    static Boundary getRightOfBoundary(shared_ptr<const GeometryObject> object, const PathHints* path) {
        return path ? getRightOfBoundary(object, *path) : getRightOfBoundary(object);
    }
 
    static Boundary getRightOfBoundary(shared_ptr<const GeometryObject> object) {
        return details::getBoundaryForBoxes< RectangularMeshBase3D >(
            [=](const shared_ptr<const GeometryD<3>>& geometry) { return geometry->getObjectBoundingBoxes(object); },
            [](const Box3D& box) { return RectangularMeshBase3D::getRightOfBoundary(box); }
        );
    }
 
    static Boundary getBottomOfBoundary(shared_ptr<const GeometryObject> object, const PathHints& path) {
        return details::getBoundaryForBoxes< RectangularMeshBase3D >(
            [=](const shared_ptr<const GeometryD<3>>& geometry) { return geometry->getObjectBoundingBoxes(object, path); },
            [](const Box3D& box) { return RectangularMeshBase3D::getBottomOfBoundary(box); }
        );
    }
 
    static Boundary getBottomOfBoundary(shared_ptr<const GeometryObject> object, const PathHints* path) {
        return path ? getBottomOfBoundary(object, *path) : getBottomOfBoundary(object);
    }
 
    static Boundary getBottomOfBoundary(shared_ptr<const GeometryObject> object) {
        return details::getBoundaryForBoxes< RectangularMeshBase3D >(
            [=](const shared_ptr<const GeometryD<3>>& geometry) { return geometry->getObjectBoundingBoxes(object); },
            [](const Box3D& box) { return RectangularMeshBase3D::getBottomOfBoundary(box); }
        );
    }
 
    static Boundary getTopOfBoundary(shared_ptr<const GeometryObject> object, const PathHints& path) {
        return details::getBoundaryForBoxes< RectangularMeshBase3D >(
            [=](const shared_ptr<const GeometryD<3>>& geometry) { return geometry->getObjectBoundingBoxes(object, path); },
            [](const Box3D& box) { return RectangularMeshBase3D::getTopOfBoundary(box); }
        );
    }
 
    static Boundary getTopOfBoundary(shared_ptr<const GeometryObject> object) {
        return details::getBoundaryForBoxes< RectangularMeshBase3D >(
            [=](const shared_ptr<const GeometryD<3>>& geometry) { return geometry->getObjectBoundingBoxes(object); },
            [](const Box3D& box) { return RectangularMeshBase3D::getTopOfBoundary(box); }
        );
    }
 
    static Boundary getTopOfBoundary(shared_ptr<const GeometryObject> object, const PathHints* path) {
        return path ? getTopOfBoundary(object, *path) : getTopOfBoundary(object);
    }
 
    static Boundary getBackOfBoundary(shared_ptr<const GeometryObject> object, const PathHints& path) {
        return details::getBoundaryForBoxes< RectangularMeshBase3D >(
            [=](const shared_ptr<const GeometryD<3>>& geometry) { return geometry->getObjectBoundingBoxes(object, path); },
            [](const Box3D& box) { return RectangularMeshBase3D::getBackOfBoundary(box); }
        );
    }
 
    static Boundary getBackOfBoundary(shared_ptr<const GeometryObject> object) {
        return details::getBoundaryForBoxes< RectangularMeshBase3D >(
            [=](const shared_ptr<const GeometryD<3>>& geometry) { return geometry->getObjectBoundingBoxes(object); },
            [](const Box3D& box) { return RectangularMeshBase3D::getBackOfBoundary(box); }
        );
    }
 
    static Boundary getBackOfBoundary(shared_ptr<const GeometryObject> object, const PathHints* path) {
        return path ? getBackOfBoundary(object, *path) : getBackOfBoundary(object);
    }
 
    static Boundary getFrontOfBoundary(shared_ptr<const GeometryObject> object, const PathHints& path) {
        return details::getBoundaryForBoxes< RectangularMeshBase3D >(
            [=](const shared_ptr<const GeometryD<3>>& geometry) { return geometry->getObjectBoundingBoxes(object, path); },
            [](const Box3D& box) { return RectangularMeshBase3D::getFrontOfBoundary(box); }
        );
    }
 
    static Boundary getFrontOfBoundary(shared_ptr<const GeometryObject> object) {
        return details::getBoundaryForBoxes< RectangularMeshBase3D >(
            [=](const shared_ptr<const GeometryD<3>>& geometry) { return geometry->getObjectBoundingBoxes(object); },
            [](const Box3D& box) { return RectangularMeshBase3D::getFrontOfBoundary(box); }
        );
    }
 
    static Boundary getFrontOfBoundary(shared_ptr<const GeometryObject> object, const PathHints* path) {
        return path ? getFrontOfBoundary(object, *path) : getFrontOfBoundary(object);
    }
 
    static Boundary getBoundary(const std::string &boundary_desc);
 
    static Boundary getBoundary(XMLReader &boundary_desc, Manager &manager);
};
 
template <>
inline RectangularMeshBase3D::Boundary parseBoundary<RectangularMeshBase3D::Boundary>(const std::string& boundary_desc, plask::Manager&) { return RectangularMeshBase3D::getBoundary(boundary_desc); }
 
template <>
inline RectangularMeshBase3D::Boundary parseBoundary<RectangularMeshBase3D::Boundary>(XMLReader& boundary_desc, Manager& env) { return RectangularMeshBase3D::getBoundary(boundary_desc, env); }
 
 
template <int DIM>
using RectangularMeshBase =
    typename std::conditional<
        DIM == 2,
        RectangularMeshBase2D,
        typename std::conditional<DIM == 3, RectangularMeshBase3D, void>::type
    >::type;
 
}   // namespace plask
 
#endif // PLASK__MESH__RECTANGULAR_COMMON_H