boundary.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__BOUNDARY_H
#define PLASK__BOUNDARY_H
 
#include "../utils/iterators.hpp"
#include "../utils/xml/reader.hpp"
#include "../memory.hpp"
#include "../log/log.hpp"
 
#include "../exceptions.hpp"
#include "../geometry/space.hpp"
#include <vector>
#include <set>
 
namespace plask {
 
struct PLASK_API BoundaryNodeSetImpl {
 
    typedef PolymorphicForwardIteratorImpl<std::size_t, std::size_t> IteratorImpl;
 
    typedef PolymorphicForwardIterator<IteratorImpl> Iterator;
 
    typedef Iterator const_iterator;
    typedef const_iterator iterator;
 
    virtual ~BoundaryNodeSetImpl() {}
 
    virtual bool contains(std::size_t mesh_index) const = 0;
 
    virtual const_iterator begin() const = 0;
 
    virtual const_iterator end() const = 0;
 
    virtual bool empty() const { return begin() == end(); }
 
    virtual std::size_t size() const { return std::size_t(std::distance(begin(), end())); }
 
};
 
template <typename MeshType>
struct BoundaryNodeSetWithMeshImpl: public BoundaryNodeSetImpl {
 
    typedef typename BoundaryNodeSetImpl::const_iterator const_iterator;
 
    typedef typename BoundaryNodeSetImpl::iterator iterator;
 
    const MeshType& mesh;
 
    BoundaryNodeSetWithMeshImpl(const MeshType& mesh)
        : mesh(mesh) {}
 
    struct IteratorWithMeshImpl: public BoundaryNodeSetImpl::IteratorImpl {
 
        const BoundaryNodeSetWithMeshImpl<MeshType>& boundaryWithMesh;
 
        const BoundaryNodeSetWithMeshImpl<MeshType>& getBoundary() const { return boundaryWithMesh; }
        const MeshType& getMesh() const { return boundaryWithMesh.mesh; }
 
        IteratorWithMeshImpl(const BoundaryNodeSetWithMeshImpl<MeshType>& boundaryImpl)
            : boundaryWithMesh(boundaryImpl) {}
    };
 
};
 
struct PLASK_API BoundaryNodeSet: public HolderRef< const BoundaryNodeSetImpl > {
 
    typedef typename BoundaryNodeSetImpl::const_iterator const_iterator;
    typedef typename BoundaryNodeSetImpl::iterator iterator;
 
    BoundaryNodeSet(const BoundaryNodeSetImpl* to_hold = nullptr): HolderRef< const BoundaryNodeSetImpl >(to_hold) {}
 
    virtual ~BoundaryNodeSet() {}
 
    bool contains(std::size_t mesh_index) const {
        return this->held->contains(mesh_index);
    }
 
    const_iterator begin() const {
        return this->held->begin();
    }
 
    const_iterator end() const {
        return this->held->end();
    }
 
    std::size_t size() const {
        return this->held->size();
    }
 
    virtual bool empty() const { return this->held->empty(); }
 
};
 
struct PLASK_API EmptyBoundaryImpl: public BoundaryNodeSetImpl {
 
    struct IteratorImpl: public BoundaryNodeSetImpl::IteratorImpl {
 
        std::size_t dereference() const override {
            throw Exception("dereference of empty boundary iterator.");
        }
 
        void increment() override {}
 
        bool equal(const typename BoundaryNodeSetImpl::IteratorImpl& PLASK_UNUSED(other)) const override {
            return true;
        }
 
        std::unique_ptr<typename BoundaryNodeSetImpl::IteratorImpl> clone() const override {
            return std::unique_ptr<typename BoundaryNodeSetImpl::IteratorImpl>(new IteratorImpl);
        }
 
    };
 
    bool contains(std::size_t PLASK_UNUSED(mesh_index)) const override { return false; }
 
    typename BoundaryNodeSetImpl::const_iterator begin() const override {
        return typename BoundaryNodeSetImpl::Iterator(new IteratorImpl);
    }
 
    typename BoundaryNodeSetImpl::const_iterator end() const override {
        return typename BoundaryNodeSetImpl::Iterator(new IteratorImpl);
    }
 
    std::size_t size() const override {
        return 0;
    }
 
    bool empty() const override { return true; }
};
 
struct PLASK_API StdSetBoundaryImpl: public BoundaryNodeSetImpl {
 
    typedef std::set<std::size_t> StdNodeSet;
 
    typedef PolymorphicForwardIteratorWrapperImpl<StdNodeSet::const_iterator, std::size_t, std::size_t> IteratorImpl;
 
    StdNodeSet set;
 
    StdSetBoundaryImpl(StdNodeSet set): set(std::move(set)) {}
 
    bool contains(std::size_t mesh_index) const override {
        return set.find(mesh_index) != set.end();
    }
 
    typename BoundaryNodeSetImpl::const_iterator begin() const override {
        return typename BoundaryNodeSetImpl::Iterator(new IteratorImpl(set.begin()));
    }
 
    typename BoundaryNodeSetImpl::const_iterator end() const override {
        return typename BoundaryNodeSetImpl::Iterator(new IteratorImpl(set.end()));
    }
 
    std::size_t size() const override {
        return set.size();
    }
 
    bool empty() const override {
        return set.empty();
    }
};
 
// TODO może wykluczyć MeshType jako parametr szablonu i dodać w zamian DIM (używać MeshD)?
template <typename MeshT>
struct Boundary {
 
    typedef MeshT MeshType;
 
protected:
    std::function<BoundaryNodeSet(const MeshType&, const shared_ptr<const GeometryD<MeshType::DIM>>&)> create;
 
public:
 
    //template <typename... T>
    //Boundary(T&&... args): create(std::forward<T>(args)...) {}
 
    Boundary(std::function<BoundaryNodeSet(const MeshType&, const shared_ptr<const GeometryD<MeshType::DIM>>&)> create_fun): create(create_fun) {}
 
    Boundary() {}
 
    //Boundary(const Boundary<MeshType>&) = default;
    //Boundary(Boundary<MeshType>&&) = default;
 
    BoundaryNodeSet operator()(const MeshType& mesh, const shared_ptr<const GeometryD<MeshType::DIM>>& geometry) const {
        if (isNull()) return new EmptyBoundaryImpl();
        return this->create(mesh, geometry);
    }
 
    BoundaryNodeSet operator()(const shared_ptr<const MeshType>& mesh, const shared_ptr<const GeometryD<MeshType::DIM>>& geometry) const {
        if (isNull()) return new EmptyBoundaryImpl();
        return this->create(*mesh, geometry);
    }
 
    BoundaryNodeSet get(const MeshType& mesh, const shared_ptr<const GeometryD<MeshType::DIM>>& geometry) const {
        if (isNull()) return new EmptyBoundaryImpl();
        return this->create(mesh, geometry);
    }
 
    BoundaryNodeSet get(const shared_ptr<const MeshType>& mesh, const shared_ptr<const GeometryD<MeshType::DIM>>& geometry) const {
        if (isNull()) return new EmptyBoundaryImpl();
        return this->create(*mesh, geometry);
    }
 
    bool empty(const MeshType& mesh) const {
        if (isNull()) return true;
        return get(mesh).empty();
    }
 
    bool isNull() const {
        return !create;
    }
};
 
template <typename MeshType, typename OpNodeSetImplT>
struct BoundaryOp {
 
    Boundary<MeshType> A, B;
 
    BoundaryOp(Boundary<MeshType> A, Boundary<MeshType> B): A(std::move(A)), B(std::move(B)) {}
 
    BoundaryNodeSet operator()(const MeshType& mesh, const shared_ptr<const GeometryD<MeshType::DIM>>& geom) const {
        return new OpNodeSetImplT(A.get(mesh, geom), B.get(mesh, geom));
    }
};
 
struct UnionBoundarySetImpl: public BoundaryNodeSetImpl {
 
    typedef std::vector< BoundaryNodeSet > BoundariesVec;
    BoundariesVec boundaries;
 
    struct IteratorImpl: public BoundaryNodeSetImpl::IteratorImpl {
 
        struct IteratorWithEnd {
            BoundaryNodeSet::const_iterator iter;
            BoundaryNodeSet::const_iterator end;
 
            IteratorWithEnd(BoundaryNodeSet::const_iterator iter, BoundaryNodeSet::const_iterator end)
                : iter(std::move(iter)), end(std::move(end)) {}
 
            bool valid() const { return iter != end; }
 
            bool operator==(const IteratorWithEnd& o) const { return iter == o.iter; }
        };
 
        std::vector<IteratorWithEnd> position;
 
        bool equal(const typename BoundaryNodeSetImpl::IteratorImpl &other) const override {
            const IteratorImpl& o = static_cast<const IteratorImpl&>(other);
            return position.size() == o.position.size() && std::equal(position.begin(), position.end(), o.position.begin());
        }
 
        std::unique_ptr<BoundaryNodeSetImpl::IteratorImpl> clone() const override {
            return std::unique_ptr<BoundaryNodeSetImpl::IteratorImpl>(new IteratorImpl(*this));
        }
 
    private:
        std::size_t minimal_position() const {
            std::size_t minimum = std::numeric_limits<std::size_t>::max();
            for (const IteratorWithEnd& v: position)
                if (v.valid()) {
                    auto vv = *v.iter;
                    if (vv < minimum) minimum = vv;
                }
            return minimum;
        }
 
    public:
        std::size_t dereference() const override {
            return minimal_position();
        }
 
        void increment() override {
            std::size_t m = minimal_position();
            for (IteratorWithEnd& v: position)
                if (v.valid() && *v.iter == m) ++v.iter;
        }
 
    };
 
    template <typename... Args>
    UnionBoundarySetImpl(Args&&... args):
        boundaries(std::forward<Args>(args)...) {   }
 
    UnionBoundarySetImpl(BoundaryNodeSet A, BoundaryNodeSet B)
        : boundaries(std::initializer_list<plask::BoundaryNodeSet>{A, B}) {}
 
    bool contains(std::size_t mesh_index) const override {
        for (auto& b: boundaries)
            if (b.contains(mesh_index)) return true;
        return false;
    }
 
    typename BoundaryNodeSetImpl::Iterator begin() const override {
        std::unique_ptr<IteratorImpl> impl(new IteratorImpl());
        impl->position.reserve(boundaries.size());
        for (const BoundaryNodeSet& b: boundaries)
            impl->position.emplace_back(b.begin(), b.end());
        return typename BoundaryNodeSetImpl::Iterator(impl.release());
    }
 
    typename BoundaryNodeSetImpl::Iterator end() const override {
        std::unique_ptr<IteratorImpl> impl(new IteratorImpl());
        impl->position.reserve(boundaries.size());
        for (const BoundaryNodeSet& b: boundaries)
            impl->position.emplace_back(b.end(), b.end());
        return typename BoundaryNodeSetImpl::Iterator(impl.release());
    }
 
    bool empty() const override {
        for (auto bound: boundaries)
            if (!bound.empty()) return false;
        return true;
    }
 
    /*std::size_t size() const override {
        std::size_t s = 0;
        for (auto bound: boundaries) s += bound.size();
        return s;
    }*/
 
    void push_back(const BoundaryNodeSet& to_append) { boundaries.push_back(to_append); }
 
    void push_back(BoundaryNodeSet&& to_append) { boundaries.push_back(std::move(to_append)); }
 
};
 
struct DiffBoundarySetImpl: public BoundaryNodeSetImpl {
 
    BoundaryNodeSet A, B;
 
    struct IteratorImpl: public BoundaryNodeSetImpl::IteratorImpl {
 
        struct IteratorWithEnd {
            BoundaryNodeSet::const_iterator iter;
            BoundaryNodeSet::const_iterator end;
 
            IteratorWithEnd(BoundaryNodeSet::const_iterator iter, BoundaryNodeSet::const_iterator end)
                : iter(std::move(iter)), end(std::move(end)) {}
 
            bool valid() const { return iter != end; }
 
            bool operator==(const IteratorWithEnd& o) const { return iter == o.iter; }
        };
 
        IteratorWithEnd Apos, Bpos;
 
    private:
        void advanceAtoNearestValidPos() {
            while (Apos.valid()) {
                const std::size_t Aindex = *Apos.iter;
                while (true) {
                    if (!Bpos.valid()) return;  // accept current Apos
                    const std::size_t Bindex = *Bpos.iter;
                    if (Bindex == Aindex) break;    // go to next A index
                    if (Bindex > Aindex) return;    // accept current Apos
                    // here Bindex < Aindex
                    ++Bpos.iter;                         // go to next B index
                }
                ++Apos.iter;
            }
        }
 
    public:
 
        IteratorImpl(BoundaryNodeSet::const_iterator Aiter, BoundaryNodeSet::const_iterator Aend,
                     BoundaryNodeSet::const_iterator Biter, BoundaryNodeSet::const_iterator Bend):
            Apos(std::move(Aiter), std::move(Aend)), Bpos(std::move(Biter), std::move(Bend))
        {
            advanceAtoNearestValidPos();
        }
 
        bool equal(const typename BoundaryNodeSetImpl::IteratorImpl &other) const override {
            const IteratorImpl& o = static_cast<const IteratorImpl&>(other);
            return Apos == o.Apos;
        }
 
        std::unique_ptr<BoundaryNodeSetImpl::IteratorImpl> clone() const override {
            return std::unique_ptr<BoundaryNodeSetImpl::IteratorImpl>(new IteratorImpl(*this));
        }
 
        std::size_t dereference() const override {
            return *Apos.iter;
        }
 
        void increment() override {
            ++Apos.iter;
            advanceAtoNearestValidPos();
        }
 
    };
 
    DiffBoundarySetImpl(BoundaryNodeSet A, BoundaryNodeSet B):
        A(std::move(A)), B(std::move(B)) {   }
 
    bool contains(std::size_t mesh_index) const override {
        return A.contains(mesh_index) && !B.contains(mesh_index);
    }
 
    typename BoundaryNodeSetImpl::Iterator begin() const override {
        return typename BoundaryNodeSetImpl::Iterator(new IteratorImpl(A.begin(), A.end(), B.begin(), B.end()));
    }
 
    typename BoundaryNodeSetImpl::Iterator end() const override {
        return typename BoundaryNodeSetImpl::Iterator(new IteratorImpl(A.end(), A.end(), B.end(), B.end()));
    }
 
    bool empty() const override {
        return begin() == end();
    }
 
};
 
 
struct IntersectionBoundarySetImpl: public BoundaryNodeSetImpl {
 
    BoundaryNodeSet A, B;
 
    struct IteratorImpl: public BoundaryNodeSetImpl::IteratorImpl {
 
        struct IteratorWithEnd {
            BoundaryNodeSet::const_iterator iter;
            BoundaryNodeSet::const_iterator end;
 
            IteratorWithEnd(BoundaryNodeSet::const_iterator iter, BoundaryNodeSet::const_iterator end)
                : iter(std::move(iter)), end(std::move(end)) {}
 
            bool valid() const { return iter != end; }
 
            bool operator==(const IteratorWithEnd& o) const { return iter == o.iter; }
        };
 
        IteratorWithEnd Apos, Bpos;
 
    private:
        void advanceToNearestValidPos() {
            while (Apos.valid()) {
                if (!Bpos.valid()) {
                    Apos.iter = Apos.end;
                    return;
                }
                const std::size_t Aindex = *Apos.iter;
                const std::size_t Bindex = *Bpos.iter;
                if (Aindex == Bindex) return;
                if (Aindex < Bindex) ++Apos.iter; else ++Bpos.iter;
            }
        }
 
    public:
 
        IteratorImpl(BoundaryNodeSet::const_iterator Aiter, BoundaryNodeSet::const_iterator Aend,
                     BoundaryNodeSet::const_iterator Biter, BoundaryNodeSet::const_iterator Bend):
            Apos(std::move(Aiter), std::move(Aend)), Bpos(std::move(Biter), std::move(Bend))
        {
            advanceToNearestValidPos();
        }
 
        bool equal(const typename BoundaryNodeSetImpl::IteratorImpl &other) const override {
            const IteratorImpl& o = static_cast<const IteratorImpl&>(other);
            return Apos == o.Apos;
        }
 
        std::unique_ptr<BoundaryNodeSetImpl::IteratorImpl> clone() const override {
            return std::unique_ptr<BoundaryNodeSetImpl::IteratorImpl>(new IteratorImpl(*this));
        }
 
        std::size_t dereference() const override {
            return *Apos.iter;
        }
 
        void increment() override {
            ++Apos.iter;
            ++Bpos.iter;
            advanceToNearestValidPos();
        }
 
    };
 
    IntersectionBoundarySetImpl(BoundaryNodeSet A, BoundaryNodeSet B):
        A(std::move(A)), B(std::move(B)) {   }
 
    bool contains(std::size_t mesh_index) const override {
        return A.contains(mesh_index) && B.contains(mesh_index);
    }
 
    typename BoundaryNodeSetImpl::Iterator begin() const override {
        return typename BoundaryNodeSetImpl::Iterator(new IteratorImpl(A.begin(), A.end(), B.begin(), B.end()));
    }
 
    typename BoundaryNodeSetImpl::Iterator end() const override {
        return typename BoundaryNodeSetImpl::Iterator(new IteratorImpl(A.end(), A.end(), B.end(), B.end()));
    }
 
    bool empty() const override {
        return begin() == end();
    }
 
};
 
template <typename MeshType> using UnionBoundary = BoundaryOp<MeshType, UnionBoundarySetImpl>;
 
template <typename MeshType> using DiffBoundary = BoundaryOp<MeshType, DiffBoundarySetImpl>;
 
template <typename MeshType> using IntersectionBoundary = BoundaryOp<MeshType, IntersectionBoundarySetImpl>;
 
 
inline BoundaryNodeSet operator+(BoundaryNodeSet left, BoundaryNodeSet right) {
    return new UnionBoundarySetImpl(std::move(left), std::move(right));
}
inline BoundaryNodeSet operator|(BoundaryNodeSet left, BoundaryNodeSet right) {
    return new UnionBoundarySetImpl(std::move(left), std::move(right));
}
 
 
inline BoundaryNodeSet operator*(BoundaryNodeSet left, BoundaryNodeSet right) {
    return new IntersectionBoundarySetImpl(std::move(left), std::move(right));
}
inline BoundaryNodeSet operator&(BoundaryNodeSet left, BoundaryNodeSet right) {
    return new IntersectionBoundarySetImpl(std::move(left), std::move(right));
}
 
inline BoundaryNodeSet operator-(BoundaryNodeSet left, BoundaryNodeSet right) {
    return new DiffBoundarySetImpl(std::move(left), std::move(right));
}
 
 
template <typename MeshType>
inline Boundary<MeshType> operator+(Boundary<MeshType> left, Boundary<MeshType> right) {
    return Boundary<MeshType>(UnionBoundary<MeshType>(std::move(left), std::move(right)));
}
template <typename MeshType>
inline Boundary<MeshType> operator|(Boundary<MeshType> left, Boundary<MeshType> right) {
    return Boundary<MeshType>(UnionBoundary<MeshType>(std::move(left), std::move(right)));
}
 
 
template <typename MeshType>
inline Boundary<MeshType> operator*(Boundary<MeshType> left, Boundary<MeshType> right) {
    return Boundary<MeshType>(IntersectionBoundary<MeshType>(std::move(left), std::move(right)));
}
template <typename MeshType>
inline Boundary<MeshType> operator&(Boundary<MeshType> left, Boundary<MeshType> right) {
    return Boundary<MeshType>(IntersectionBoundary<MeshType>(std::move(left), std::move(right)));
}
 
template <typename MeshType>
inline Boundary<MeshType> operator-(Boundary<MeshType> left, Boundary<MeshType> right) {
    return Boundary<MeshType>(DiffBoundary<MeshType>(std::move(left), std::move(right)));
}
 
template <typename MeshT, typename Predicate>
struct PredicateBoundaryImpl: public BoundaryNodeSetWithMeshImpl<typename MeshT::Boundary::MeshType> {
 
    typedef typename MeshT::Boundary::MeshType MeshType;
 
    struct PredicateIteratorImpl: public BoundaryNodeSetWithMeshImpl<MeshType>::IteratorWithMeshImpl {
 
       typedef decltype(std::begin(std::declval<MeshType>())) MeshBeginIterator;
       typedef decltype(std::end(std::declval<MeshType>())) MeshEndIterator;
 
       MeshBeginIterator meshIterator;
       MeshEndIterator meshIteratorEnd;
 
       PredicateIteratorImpl(const BoundaryNodeSetWithMeshImpl<MeshType>& boundary, MeshBeginIterator meshIterator):
            BoundaryNodeSetWithMeshImpl<MeshType>::IteratorWithMeshImpl(boundary),
            meshIterator(meshIterator),
            meshIteratorEnd(std::end(boundary.mesh)) {
           while (this->meshIterator != meshIteratorEnd && !check_predicate())
               ++this->meshIterator;  //go to first element which fulfill predicate
       }
 
        std::size_t dereference() const override {
            return meshIterator.getIndex();
        }
 
      private:
        bool check_predicate() {
            return static_cast<const PredicateBoundaryImpl&>(this->getBoundary())
                .predicate(this->getMesh(), meshIterator.getIndex());
        }
 
      public:
 
        void increment() override {
            do {
                ++meshIterator;
            } while (meshIterator != meshIteratorEnd && !check_predicate());
        }
 
        bool equal(const typename BoundaryNodeSetImpl::IteratorImpl& other) const override {
            return meshIterator == static_cast<const PredicateIteratorImpl&>(other).meshIterator;
        }
 
        std::unique_ptr<typename BoundaryNodeSetImpl::IteratorImpl> clone() const override {
            return std::unique_ptr<typename BoundaryNodeSetImpl::IteratorImpl>(new PredicateIteratorImpl(*this));
        }
 
    };
 
    Predicate predicate;
 
    PredicateBoundaryImpl(const MeshType& mesh, Predicate predicate):
        BoundaryNodeSetWithMeshImpl<MeshType>(mesh), predicate(predicate) {}
 
    //virtual PredicateBoundary<MeshType, Predicate>* clone() const { return new PredicateBoundary<MeshType, Predicate>(predicate); }
 
private:
    bool check_predicate(std::size_t mesh_index) const {
        return predicate(this->mesh, mesh_index);
    }
 
public:
 
    bool contains(std::size_t mesh_index) const override {
        return this->check_predicate(mesh_index);
    }
 
    typename BoundaryNodeSetImpl::Iterator begin() const override {
        return typename BoundaryNodeSetImpl::Iterator(new PredicateIteratorImpl(*this, std::begin(this->mesh)));
    }
 
    typename BoundaryNodeSetImpl::Iterator end() const override {
        return typename BoundaryNodeSetImpl::Iterator(new PredicateIteratorImpl(*this, std::end(this->mesh)));
    }
 
};
 
template <typename MeshType>
inline typename MeshType::Boundary makeEmptyBoundary() {
    return typename MeshType::Boundary(
        [](const MeshType&, const shared_ptr<const GeometryD<MeshType::DIM>>&) { return new EmptyBoundaryImpl(); }
    );
}
 
 
template <typename Boundary, typename Predicate>
inline Boundary makePredicateBoundary(Predicate predicate) {
    return Boundary( [=](const typename Boundary::MeshType& mesh, const shared_ptr<const GeometryD<Boundary::MeshType::DIM>>&) {
        return new PredicateBoundaryImpl<typename Boundary::MeshType, Predicate>(mesh, predicate);
    } );
}
 
struct Manager;
 
 
template <typename Boundary>
inline Boundary parseBoundary(const std::string& PLASK_UNUSED(boundary_desc), Manager& PLASK_UNUSED(manager)) { return Boundary(); }
 
 
template <typename Boundary>
inline Boundary parseBoundary(XMLReader& PLASK_UNUSED(boundary_desc), Manager& PLASK_UNUSED(manager)) { return Boundary(); }
 
}   // namespace plask
 
#endif // PLASK__BOUNDARY_H